Crear y administrar almacenes de DICOM

En esta página, se explica cómo crear, editar, ver y borrar tiendas de Imágenes digitales y comunicación en medicina (DICOM). Para obtener más información sobre cómo la API de Cloud Healthcare se ajusta al estándar DICOM, consulta la Declaración de conformidad de DICOM.

Crea un almacén de DICOM

Antes de crear un almacén de DICOM, debes crear un conjunto de datos.

En los siguientes ejemplos, se muestra cómo crear un almacén DICOM.

Console

Para crear una tienda de DICOM, haz lo siguiente:

1. En Cloud Console, ve a la página Conjuntos de datos.

   Ir a la página Conjuntos de datos

2. Abre el conjunto de datos en el que deseas crear una tienda de DICOM.
3. Haz clic en Crear almacén de datos.
4. Ingresa un nombre de tu elección que sea único en tu conjunto de datos. Si el nombre no es único, la creación del almacén de datos fallará.
5. Selecciona DICOM como el tipo de almacén de datos.
6. Si deseas configurar un tema de Pub/Sub para el almacén de datos, escribe el nombre del tema. Cuando especifiques un tema de Pub/Sub, ingresa el URI calificado para el tema, como se muestra en el siguiente ejemplo:

   projects/PROJECT_ID/topics/PUBSUB_TOPIC
   

7. Haga clic en Crear.

El nuevo almacén de datos aparece en la lista.

gcloud

Para crear un almacén de DICOM en el conjunto de datos, ejecuta el comando gcloud healthcare dicom-stores create.

• El ID del almacén de DICOM debe ser único en el conjunto de datos. Puede ser cualquier string Unicode de 1 a 256 caracteres que conste de números, letras, guiones bajos, guiones y puntos.
• Para notificar un tema de Pub/Sub de los cambios del almacén de DICOM, especifica un nombre de tema de Pub/Sub existente con el argumento --pubsub-topic. Cuando especifiques un tema de Pub/Sub, ingresa el URI calificado para el tema, como se muestra en el siguiente ejemplo:

  projects/PROJECT_ID/topics/PUBSUB_TOPIC
  

En el siguiente ejemplo, se muestra cómo crear un almacén de DICOM

gcloud healthcare dicom-stores create DICOM_STORE_ID \
  --dataset=DATASET_ID \
  --location=LOCATION \
  [--pubsub-topic=projects/PROJECT_ID/topics/PUBSUB_TOPIC]

Si la solicitud se realiza correctamente, el símbolo del sistema muestra lo siguiente:

Created dicomStore [DICOM_STORE_ID].

API

Para crear un almacén de DICOM, usa el método projects.locations.datasets.dicomStores.create.

curl

Para crear un almacén de DICOM, realiza una solicitud POST y especifica la siguiente información:

• El nombre y la ubicación del conjunto de datos superior
• Un nombre para el almacén de DICOM. El ID del almacén de DICOM debe ser único en su conjunto de datos superior. Puede ser cualquier string Unicode de 1 a 256 caracteres que conste de números, letras, guiones bajos, guiones y puntos.
• Un token de acceso
• De manera opcional, un tema existente de Pub/Sub al que la API de Cloud Healthcare envía notificaciones de los cambios del almacén de DICOM. Consulta Edita un almacén de DICOM para obtener información sobre cómo configurar el tema de Pub/Sub.

En el siguiente ejemplo, se muestra una solicitud POST mediante curl:

curl -X POST \
    --data "" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores?dicomStoreId=DICOM_STORE_ID"

Si la solicitud tiene éxito, se mostrará la siguiente respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID"
}

PowerShell

Para crear un almacén de DICOM, realiza una solicitud POST y especifica la siguiente información:

• El nombre y la ubicación del conjunto de datos superior
• Un nombre para el almacén de DICOM. El ID del almacén de DICOM debe ser único en su conjunto de datos superior. Puede ser cualquier string Unicode de 1 a 256 caracteres que conste de números, letras, guiones bajos, guiones y puntos.
• Un token de acceso
• De manera opcional, un tema existente de Pub/Sub al que la API de Cloud Healthcare envía notificaciones de los cambios del almacén de DICOM. Consulta Edita un almacén de DICOM para obtener información sobre cómo configurar el tema de Pub/Sub.

En el siguiente ejemplo, se muestra una solicitud POST mediante Windows PowerShell.

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Post `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores?dicomStoreId=DICOM_STORE_ID" | Select-Object -Expand Content

Si la solicitud tiene éxito, en el servidor se mostrará una respuesta similar a la siguiente muestra en formato JSON:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID"
}

Comienza a usarlo

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

	healthcare "google.golang.org/api/healthcare/v1"
)

// createDICOMStore creates a DICOM store.
func createDICOMStore(w io.Writer, projectID, location, datasetID, dicomStoreID string) error {
	ctx := context.Background()

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %v", err)
	}

	storesService := healthcareService.Projects.Locations.Datasets.DicomStores

	store := &healthcare.DicomStore{}
	parent := fmt.Sprintf("projects/%s/locations/%s/datasets/%s", projectID, location, datasetID)

	resp, err := storesService.Create(parent, store).DicomStoreId(dicomStoreID).Do()
	if err != nil {
		return fmt.Errorf("Create: %v", err)
	}

	fmt.Fprintf(w, "Created DICOM store: %q\n", resp.Name)
	return nil
}

Java

Ver en GitHub Comentarios

import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcare.Projects.Locations.Datasets.DicomStores;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.api.services.healthcare.v1.model.DicomStore;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class DicomStoreCreate {
  private static final String DATASET_NAME = "projects/%s/locations/%s/datasets/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void dicomStoreCreate(String datasetName, String dicomStoreId) throws IOException {
    // String datasetName =
    //     String.format(DATASET_NAME, "your-project-id", "your-region-id", "your-dataset-id");

    // Initialize the client, which will be used to interact with the service.
    CloudHealthcare client = createClient();

    // Configure the dicomStore to be created.
    Map<String, String> labels = new HashMap<String, String>();
    labels.put("key1", "value1");
    labels.put("key2", "value2");
    DicomStore content = new DicomStore().setLabels(labels);

    // Create request and configure any parameters.
    DicomStores.Create request =
        client
            .projects()
            .locations()
            .datasets()
            .dicomStores()
            .create(datasetName, content)
            .setDicomStoreId(dicomStoreId);

    // Execute the request and process the results.
    DicomStore response = request.execute();
    System.out.println("DICOM store created: " + response.toPrettyString());
  }

  private static CloudHealthcare createClient() throws IOException {
    // Use Application Default Credentials (ADC) to authenticate the requests
    // For more information see https://cloud.google.com/docs/authentication/production
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    // Create a HttpRequestInitializer, which will provide a baseline configuration to all requests.
    HttpRequestInitializer requestInitializer =
        request -> {
          new HttpCredentialsAdapter(credential).initialize(request);
          request.setConnectTimeout(60000); // 1 minute connect timeout
          request.setReadTimeout(60000); // 1 minute read timeout
        };

    // Build the client for interacting with the service.
    return new CloudHealthcare.Builder(HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
        .setApplicationName("your-application-name")
        .build();
  }
}

Node.js

Ver en GitHubComentarios

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');

const createDicomStore = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth});

  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const dicomStoreId = 'my-dicom-store';
  const parent = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}`;
  const request = {parent, dicomStoreId};

  await healthcare.projects.locations.datasets.dicomStores.create(request);
  console.log(`Created DICOM store: ${dicomStoreId}`);
};

createDicomStore();

Python

Ver en GitHubComentarios

def create_dicom_store(project_id, cloud_region, dataset_id, dicom_store_id):
    """Creates a new DICOM store within the parent dataset."""
    client = get_client()
    dicom_store_parent = "projects/{}/locations/{}/datasets/{}".format(
        project_id, cloud_region, dataset_id
    )

    request = (
        client.projects()
        .locations()
        .datasets()
        .dicomStores()
        .create(parent=dicom_store_parent, body={}, dicomStoreId=dicom_store_id)
    )

    response = request.execute()
    print("Created DICOM store: {}".format(dicom_store_id))
    return response

Edita un almacén de DICOM

En los siguientes ejemplos, se muestra cómo realizar los siguientes cambios en un almacén de DICOM:

• Edita el tema de Pub/Sub al que la API de Cloud Healthcare envía las notificaciones de los cambios del almacén de DICOM.
• Edita las etiquetas. Las etiquetas son pares clave-valor que te ayudan a organizar tus recursos de Google Cloud.

Cuando especifiques un tema de Pub/Sub, ingresa el URI calificado para el tema, como se muestra en el siguiente ejemplo:

projects/PROJECT_ID/topics/PUBSUB_TOPIC

Para que las notificaciones funcionen, debes otorgar permisos adicionales a la cuenta de servicio del Agente de servicios de Cloud Healthcare. Para obtener más información, consulta Permisos de Pub/Sub de DICOM, FHIR y HL7v2.

Console

Cloud Console no admite la edición del tema o las etiquetas de Pub/Sub. En su lugar, usa curl, Windows PowerShell o tu lenguaje preferido.

gcloud

Para actualizar la tienda de DICOM, ejecuta el comando gcloud healthcare dicom-stores update.

En la siguiente muestra, se muestra cómo actualizar el tema de Pub/Sub del almacén de DICOM. La herramienta de gcloud no admite la edición de etiquetas.

gcloud healthcare dicom-stores update DICOM_STORE_ID \
  --dataset=DATASET_ID \
  --location=LOCATION \
  --pubsub-topic=projects/PROJECT_ID/topics/PUBSUB_TOPIC

Si la solicitud es exitosa, el símbolo del sistema muestra los detalles del almacén de DICOM, incluido el nuevo nombre del tema:

Updated dicomStore [DICOM_STORE_ID].
name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicom-stores/DICOM_STORE_ID
notificationConfig:
pubsubTopic: projects/PROJECT_ID/topics/PUBSUB_TOPIC

API

Para editar un almacén de DICOM, usa el método projects.locations.datasets.dicomStores.patch.

curl

Para editar un almacén DICOM, realiza una solicitud PATCH y especifica la siguiente información:

• El nombre y la ubicación del conjunto de datos superior
• El nombre del almacén de DICOM
• Los metadatos que deseas actualizar En este ejemplo, el URI calificado para el tema de Pub/Sub y las etiquetas que se actualizarán como una lista delimitada por comas de pares clave-valor.
• Una máscara de actualización
• Un token de acceso

En el siguiente ejemplo, se muestra una solicitud PATCH mediante curl:

curl -X PATCH \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    --data "{
      'notificationConfig': {
        'pubsubTopic':'projects/PROJECT_ID/topics/PUBSUB_TOPIC'
      },
      'labels': {
        'KEY1':'VALUE1','KEY2':'VALUE2'
      }
    }" \
    "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID?updateMask=notificationConfig,labels"

Si la solicitud tiene éxito, en el servidor se mostrará una respuesta similar a la siguiente muestra en formato JSON:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID",
  "notificationConfig": {
    "pubsubTopic": "projects/PROJECT_ID/topics/PUBSUB_TOPIC"
  },
  'labels': {
    'KEY1':'VALUE1','KEY2':'VALUE2'
  }
}

PowerShell

Para editar un almacén DICOM, realiza una solicitud PATCH y especifica la siguiente información:

• El nombre y la ubicación del conjunto de datos superior
• El nombre del almacén de DICOM
• Los metadatos que deseas actualizar En este ejemplo, el URI calificado para el tema de Pub/Sub y las etiquetas que se actualizarán como una lista delimitada por comas de pares clave-valor.
• Una máscara de actualización
• Un token de acceso

En el siguiente ejemplo, se muestra una solicitud PATCH mediante Windows PowerShell.

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Patch `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Body "{
      'notificationConfig': {
        'pubsubTopic': 'projects/PROJECT_ID/topics/PUBSUB_TOPIC'
      },
      'labels': {
        'KEY1':'VALUE1','KEY2':'VALUE2'
      }
  }" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID?updateMask=notificationConfig,labels" | Select-Object -Expand Content

Si la solicitud tiene éxito, en el servidor se mostrará una respuesta similar a la siguiente muestra en formato JSON:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID",
  "notificationConfig": {
    "pubsubTopic": "projects/PROJECT_ID/topics/PUBSUB_TOPIC"
  },
  'labels': {
    'KEY1':'VALUE1','KEY2':'VALUE2'
  }
}

Comienza a usarlo

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

	healthcare "google.golang.org/api/healthcare/v1"
)

// patchDICOMStore updates (patches) a DICOM store by updating its Pub/sub topic name.
func patchDICOMStore(w io.Writer, projectID, location, datasetID, dicomStoreID, topicName string) error {
	ctx := context.Background()

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %v", err)
	}

	storesService := healthcareService.Projects.Locations.Datasets.DicomStores

	name := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/dicomStores/%s", projectID, location, datasetID, dicomStoreID)

	if _, err := storesService.Patch(name, &healthcare.DicomStore{
		NotificationConfig: &healthcare.NotificationConfig{
			PubsubTopic: topicName, // format is "projects/*/locations/*/topics/*"
		},
	}).UpdateMask("notificationConfig").Do(); err != nil {
		return fmt.Errorf("Patch: %v", err)
	}

	fmt.Fprintf(w, "Patched DICOM store %s with Pub/sub topic %s\n", datasetID, topicName)

	return nil
}

Java

Ver en GitHub Comentarios

import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcare.Projects.Locations.Datasets.DicomStores;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.api.services.healthcare.v1.model.DicomStore;
import com.google.api.services.healthcare.v1.model.NotificationConfig;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;

public class DicomStorePatch {
  private static final String DICOM_NAME = "projects/%s/locations/%s/datasets/%s/dicomStores/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void patchDicomStore(String dicomStoreName, String pubsubTopic) throws IOException {
    // String dicomStoreName =
    //    String.format(
    //        DICOM_NAME, "your-project-id", "your-region-id", "your-dataset-id", "your-dicom-id");
    // String pubsubTopic = "your-pubsub-topic";

    // Initialize the client, which will be used to interact with the service.
    CloudHealthcare client = createClient();

    // Fetch the initial state of the DICOM store.
    DicomStores.Get getRequest =
        client.projects().locations().datasets().dicomStores().get(dicomStoreName);
    DicomStore store = getRequest.execute();

    // Update the DicomStore fields as needed as needed. For a full list of DicomStore fields, see:
    // https://cloud.google.com/healthcare/docs/reference/rest/v1/projects.locations.datasets.dicomStores#DicomStore
    store.setNotificationConfig(new NotificationConfig().setPubsubTopic(pubsubTopic));

    // Create request and configure any parameters.
    DicomStores.Patch request =
        client
            .projects()
            .locations()
            .datasets()
            .dicomStores()
            .patch(dicomStoreName, store)
            .setUpdateMask("notificationConfig");

    // Execute the request and process the results.
    store = request.execute();
    System.out.println("DICOM store patched: \n" + store.toPrettyString());
  }

  private static CloudHealthcare createClient() throws IOException {
    // Use Application Default Credentials (ADC) to authenticate the requests
    // For more information see https://cloud.google.com/docs/authentication/production
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    // Create a HttpRequestInitializer, which will provide a baseline configuration to all requests.
    HttpRequestInitializer requestInitializer =
        request -> {
          new HttpCredentialsAdapter(credential).initialize(request);
          request.setConnectTimeout(60000); // 1 minute connect timeout
          request.setReadTimeout(60000); // 1 minute read timeout
        };

    // Build the client for interacting with the service.
    return new CloudHealthcare.Builder(HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
        .setApplicationName("your-application-name")
        .build();
  }
}

Node.js

Ver en GitHubComentarios

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');

const patchDicomStore = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth});

  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const dicomStoreId = 'my-dicom-store';
  // const pubsubTopic = 'my-topic'
  const name = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/dicomStores/${dicomStoreId}`;
  const request = {
    name,
    updateMask: 'notificationConfig',
    resource: {
      notificationConfig: {
        pubsubTopic: `projects/${projectId}/topics/${pubsubTopic}`,
      },
    },
  };

  await healthcare.projects.locations.datasets.dicomStores.patch(request);
  console.log(
    `Patched DICOM store ${dicomStoreId} with Cloud Pub/Sub topic ${pubsubTopic}`
  );
};

patchDicomStore();

Python

Ver en GitHubComentarios

def patch_dicom_store(
    project_id, cloud_region, dataset_id, dicom_store_id, pubsub_topic
):
    """Updates the DICOM store."""
    client = get_client()
    dicom_store_parent = "projects/{}/locations/{}/datasets/{}".format(
        project_id, cloud_region, dataset_id
    )
    dicom_store_name = "{}/dicomStores/{}".format(dicom_store_parent, dicom_store_id)

    patch = {
        "notificationConfig": {
            "pubsubTopic": "projects/{}/topics/{}".format(project_id, pubsub_topic)
        }
    }

    request = (
        client.projects()
        .locations()
        .datasets()
        .dicomStores()
        .patch(name=dicom_store_name, updateMask="notificationConfig", body=patch)
    )

    response = request.execute()
    print(
        "Patched DICOM store {} with Cloud Pub/Sub topic: {}".format(
            dicom_store_id, pubsub_topic
        )
    )

    return response

Obtén detalles de un almacén de DICOM

En los siguientes ejemplos, se muestra cómo obtener los detalles sobre un almacén de DICOM.

Console

Para ver los detalles de un almacén de DICOM, debes hacer lo siguiente:

1. En Cloud Console, ve a la página Conjuntos de datos.

   Ir a la página Conjuntos de datos

2. Haz clic en el ID del conjunto de datos que contiene la tienda de DICOM.
3. Haga clic en el nombre del almacén de DICOM.

gcloud

Para obtener más detalles sobre un almacén de DICOM, ejecuta el comando de gcloud healthcare dicom-stores describe.

En el siguiente ejemplo, se muestra cómo obtener detalles sobre un almacén de DICOM.

gcloud healthcare dicom-stores describe DICOM_STORE_ID \
  --dataset=DATASET_ID \
  --location=LOCATION

Si la solicitud se realiza correctamente, el símbolo del sistema muestra los detalles del almacén de DICOM:

name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicom-stores/DICOM_STORE_ID

API

Para obtener más detalles sobre un almacén de DICOM, usa el método projects.locations.datasets.dicomStores.get.

curl

Para obtener detalles sobre un almacén de DICOM, realiza una solicitud GET y especifica la siguiente información:

• El nombre y la ubicación del conjunto de datos superior
• El nombre del almacén de DICOM
• Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante curl:

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID"

Si la solicitud tiene éxito, en el servidor se mostrará una respuesta similar a la siguiente muestra en formato JSON:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID"
}

Si configuraste algún campo en el recurso DicomStore, también aparecerá en la respuesta.

PowerShell

Para obtener detalles sobre un almacén de DICOM, realiza una solicitud GET y especifica la siguiente información:

• El nombre y la ubicación del conjunto de datos superior
• El nombre del almacén de DICOM
• Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante Windows PowerShell.

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Get `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID" | Select-Object -Expand Content

Si la solicitud tiene éxito, en el servidor se mostrará una respuesta similar a la siguiente muestra en formato JSON:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID"
}

Si configuraste algún campo en el recurso DicomStore, también aparecerá en la respuesta.

Comienza a usarlo

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

	healthcare "google.golang.org/api/healthcare/v1"
)

// getDICOMStore gets a DICOM store.
func getDICOMStore(w io.Writer, projectID, location, datasetID, dicomStoreID string) error {
	ctx := context.Background()

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %v", err)
	}

	storesService := healthcareService.Projects.Locations.Datasets.DicomStores

	name := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/dicomStores/%s", projectID, location, datasetID, dicomStoreID)

	store, err := storesService.Get(name).Do()
	if err != nil {
		return fmt.Errorf("Get: %v", err)
	}

	fmt.Fprintf(w, "Got DICOM store: %+v\n", store)
	return nil
}

Java

Ver en GitHub Comentarios

import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcare.Projects.Locations.Datasets.DicomStores;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.api.services.healthcare.v1.model.DicomStore;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;

public class DicomStoreGet {
  private static final String DICOM_NAME = "projects/%s/locations/%s/datasets/%s/dicomStores/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void dicomeStoreGet(String dicomStoreName) throws IOException {
    // String dicomStoreName =
    //    String.format(
    //        DICOM_NAME, "your-project-id", "your-region-id", "your-dataset-id", "your-dicom-id");

    // Initialize the client, which will be used to interact with the service.
    CloudHealthcare client = createClient();

    // Create request and configure any parameters.
    DicomStores.Get request =
        client.projects().locations().datasets().dicomStores().get(dicomStoreName);

    // Execute the request and process the results.
    DicomStore store = request.execute();
    System.out.println("DICOM store retrieved: \n" + store.toPrettyString());
  }

  private static CloudHealthcare createClient() throws IOException {
    // Use Application Default Credentials (ADC) to authenticate the requests
    // For more information see https://cloud.google.com/docs/authentication/production
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    // Create a HttpRequestInitializer, which will provide a baseline configuration to all requests.
    HttpRequestInitializer requestInitializer =
        request -> {
          new HttpCredentialsAdapter(credential).initialize(request);
          request.setConnectTimeout(60000); // 1 minute connect timeout
          request.setReadTimeout(60000); // 1 minute read timeout
        };

    // Build the client for interacting with the service.
    return new CloudHealthcare.Builder(HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
        .setApplicationName("your-application-name")
        .build();
  }
}

Node.js

Ver en GitHubComentarios

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');

const getDicomStore = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth});

  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const dicomStoreId = 'my-dicom-store';
  const name = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/dicomStores/${dicomStoreId}`;
  const request = {name};

  const dicomStore = await healthcare.projects.locations.datasets.dicomStores.get(
    request
  );
  console.log(dicomStore.data);
};

getDicomStore();

Python

Ver en GitHubComentarios

def get_dicom_store(project_id, cloud_region, dataset_id, dicom_store_id):
    """Gets the specified DICOM store."""
    client = get_client()
    dicom_store_parent = "projects/{}/locations/{}/datasets/{}".format(
        project_id, cloud_region, dataset_id
    )
    dicom_store_name = "{}/dicomStores/{}".format(dicom_store_parent, dicom_store_id)

    dicom_stores = client.projects().locations().datasets().dicomStores()
    dicom_store = dicom_stores.get(name=dicom_store_name).execute()

    print(json.dumps(dicom_store, indent=2))
    return dicom_store

Enumera las tiendas de DICOM en un conjunto de datos

En los siguientes ejemplos, se muestra cómo enumerar los almacenes DICOM en un conjunto de datos.

Console

Para ver los almacenes de datos en un conjunto de datos, haz lo siguiente:

1. En Cloud Console, ve a la página Conjuntos de datos.

   Ir a la página Conjuntos de datos

2. Haz clic en el ID del conjunto de datos cuyos datos deseas ver.

gcloud

Para mostrar una lista de los almacenes de DICOM en un conjunto de datos, ejecuta el comando de gcloud healthcare dicom-stores list.

gcloud healthcare dicom-stores list --dataset=DATASET_ID

Si la solicitud se realiza de forma correcta, el símbolo del sistema muestra una lista de los almacenes de DICOM:

ID              LOCATION     TOPIC
DICOM_STORE_ID  LOCATION       projects/PROJECT_ID/topics/PUBSUB_TOPIC

API

Para mostrar una lista de los almacenes DICOM en un conjunto de datos, usa el método projects.locations.datasets.dicomStores.list.

curl

Para mostrar una lista de los almacenes de DICOM en un conjunto de datos, realiza una solicitud GET y especifica la siguiente información:

• El nombre y la ubicación del conjunto de datos superior
• Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante curl:

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores"

Si la solicitud tiene éxito, en el servidor se mostrará una respuesta similar a la siguiente muestra en formato JSON:

{
  "dicomStores": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID"
    },
    {
      ...
    }
  ]
}

Si configuraste algún campo en el recurso DicomStore, también aparecerá en la respuesta.

PowerShell

Para mostrar una lista de los almacenes de DICOM en un conjunto de datos, realiza una solicitud GET y especifica la siguiente información:

• El nombre del conjunto de datos superior
• Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante Windows PowerShell.

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Get `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores" | Select-Object -Expand Content

Si la solicitud tiene éxito, en el servidor se mostrará una respuesta similar a la siguiente muestra en formato JSON:

{
  "dicomStores": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID"
    },
    {
      ...
    }
  ]
}

Si configuraste algún campo en el recurso DicomStore, también aparecerá en la respuesta.

Comienza a usarlo

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

	healthcare "google.golang.org/api/healthcare/v1"
)

// listDICOMStores prints a list of DICOM stores to w.
func listDICOMStores(w io.Writer, projectID, location, datasetID string) error {
	ctx := context.Background()

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %v", err)
	}

	storesService := healthcareService.Projects.Locations.Datasets.DicomStores

	parent := fmt.Sprintf("projects/%s/locations/%s/datasets/%s", projectID, location, datasetID)

	resp, err := storesService.List(parent).Do()
	if err != nil {
		return fmt.Errorf("List: %v", err)
	}

	fmt.Fprintln(w, "DICOM Stores:")
	for _, s := range resp.DicomStores {
		fmt.Fprintln(w, s.Name)
	}
	return nil
}

Java

Ver en GitHub Comentarios

import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcare.Projects.Locations.Datasets.DicomStores;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.api.services.healthcare.v1.model.DicomStore;
import com.google.api.services.healthcare.v1.model.ListDicomStoresResponse;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class DicomStoreList {
  private static final String DATASET_NAME = "projects/%s/locations/%s/datasets/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void dicomStoreList(String datasetName) throws IOException {
    // String datasetName =
    //     String.format(DATASET_NAME, "your-project-id", "your-region-id", "your-dataset-id");

    // Initialize the client, which will be used to interact with the service.
    CloudHealthcare client = createClient();

    // Results are paginated, so multiple queries may be required.
    String pageToken = null;
    List<DicomStore> stores = new ArrayList<>();
    do {
      // Create request and configure any parameters.
      DicomStores.List request =
          client
              .projects()
              .locations()
              .datasets()
              .dicomStores()
              .list(datasetName)
              .setPageSize(100) // Specify pageSize up to 1000
              .setPageToken(pageToken);

      // Execute response and collect results.
      ListDicomStoresResponse response = request.execute();
      stores.addAll(response.getDicomStores());

      // Update the page token for the next request.
      pageToken = response.getNextPageToken();
    } while (pageToken != null);

    // Print results.
    System.out.printf("Retrieved %s DICOM stores: \n", stores.size());
    for (DicomStore data : stores) {
      System.out.println("\t" + data.toPrettyString());
    }
  }

  private static CloudHealthcare createClient() throws IOException {
    // Use Application Default Credentials (ADC) to authenticate the requests
    // For more information see https://cloud.google.com/docs/authentication/production
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    // Create a HttpRequestInitializer, which will provide a baseline configuration to all requests.
    HttpRequestInitializer requestInitializer =
        request -> {
          new HttpCredentialsAdapter(credential).initialize(request);
          request.setConnectTimeout(60000); // 1 minute connect timeout
          request.setReadTimeout(60000); // 1 minute read timeout
        };

    // Build the client for interacting with the service.
    return new CloudHealthcare.Builder(HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
        .setApplicationName("your-application-name")
        .build();
  }
}

Node.js

Ver en GitHubComentarios

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');

const listDicomStores = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth});

  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  const parent = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}`;
  const request = {parent};

  const dicomStores = await healthcare.projects.locations.datasets.dicomStores.list(
    request
  );
  console.log(dicomStores.data);
};

listDicomStores();

Python

Ver en GitHubComentarios

def list_dicom_stores(project_id, cloud_region, dataset_id):
    """Lists the DICOM stores in the given dataset."""
    client = get_client()
    dicom_store_parent = "projects/{}/locations/{}/datasets/{}".format(
        project_id, cloud_region, dataset_id
    )

    dicom_stores = (
        client.projects()
        .locations()
        .datasets()
        .dicomStores()
        .list(parent=dicom_store_parent)
        .execute()
        .get("dicomStores", [])
    )

    for dicom_store in dicom_stores:
        print(dicom_store)

    return dicom_stores

Borra un almacén de DICOM

Precaución: Si borrar un almacén de DICOM, también se borrarán las instancias de los objetos en el almacén de DICOM. Si se borran, estos datos no se podrán recuperar. Las instancias de los objetos de DICOM que se exportaron a Cloud Storage no se ven afectadas.

En los siguientes ejemplos, se muestra cómo borrar un almacén de DICOM.

Console

Para borrar un almacén de datos, realiza las siguientes acciones:

1. En Cloud Console, ve a la página Conjuntos de datos.

   Ir a la página Conjuntos de datos

2. Haz clic en el ID del conjunto de datos para abrirlo.
3. Selecciona el almacén de datos que deseas borrar y, luego, haz clic en Borrar.
4. Para confirmar, escribe el nombre del almacén de datos y, luego, haz clic en Borrar.

gcloud

Para borrar un almacén de DICOM, ejecuta el comando de gcloud healthcare dicom-stores delete:

1. Ejecuta el comando delete.

gcloud healthcare dicom-stores delete DICOM_STORE_ID \
  --dataset=DATASET_ID \
  --location=LOCATION

1. Para confirmar, escribe Y.

Si la solicitud se realiza correctamente, el símbolo del sistema muestra la siguiente respuesta:

Deleted dicomStore [DICOM_STORE_ID].

API

Para borrar un almacén de DICOM, usa el método projects.locations.datasets.dicomStores.delete.

curl

Para borrar un almacén de DICOM, realiza una solicitud DELETE y especifica la siguiente información:

• El nombre y la ubicación del conjunto de datos superior
• El nombre del almacén de DICOM que se borrará
• Un token de acceso

En el siguiente ejemplo, se muestra una solicitud DELETE mediante curl:

curl -X DELETE \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID"

Si la solicitud se realiza con éxito, el servidor muestra el cuerpo de la respuesta vacío en formato JSON:

{}

PowerShell

Para borrar un almacén de DICOM, realiza una solicitud DELETE y especifica la siguiente información:

• El nombre y la ubicación del conjunto de datos superior
• El nombre del almacén de DICOM que se borrará
• Un token de acceso

En el siguiente ejemplo, se muestra una solicitud DELETE mediante Windows PowerShell.

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Delete `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID" | Select-Object -Expand Content

Si la solicitud se realiza con éxito, el servidor muestra el cuerpo de la respuesta vacío en formato JSON:

{}

Go

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

	healthcare "google.golang.org/api/healthcare/v1"
)

// deleteDICOMStore deletes an DICOM store.
func deleteDICOMStore(w io.Writer, projectID, location, datasetID, dicomStoreID string) error {
	ctx := context.Background()

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %v", err)
	}

	storesService := healthcareService.Projects.Locations.Datasets.DicomStores

	name := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/dicomStores/%s", projectID, location, datasetID, dicomStoreID)
	if _, err := storesService.Delete(name).Do(); err != nil {
		return fmt.Errorf("Delete: %v", err)
	}

	fmt.Fprintf(w, "Deleted DICOM store: %q\n", name)
	return nil
}

Java

Ver en GitHub Comentarios

import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcare.Projects.Locations.Datasets.DicomStores;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;

public class DicomStoreDelete {
  private static final String DICOM_NAME = "projects/%s/locations/%s/datasets/%s/dicomStores/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void deleteDicomStore(String dicomStoreName) throws IOException {
    // String dicomStoreName =
    //    String.format(
    //        DICOM_NAME, "your-project-id", "your-region-id", "your-dataset-id", "your-dicom-id");

    // Initialize the client, which will be used to interact with the service.
    CloudHealthcare client = createClient();

    // Create request and configure any parameters.
    DicomStores.Delete request =
        client.projects().locations().datasets().dicomStores().delete(dicomStoreName);

    // Execute the request and process the results.
    request.execute();
    System.out.println("DICOM store deleted.");
  }

  private static CloudHealthcare createClient() throws IOException {
    // Use Application Default Credentials (ADC) to authenticate the requests
    // For more information see https://cloud.google.com/docs/authentication/production
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    // Create a HttpRequestInitializer, which will provide a baseline configuration to all requests.
    HttpRequestInitializer requestInitializer =
        request -> {
          new HttpCredentialsAdapter(credential).initialize(request);
          request.setConnectTimeout(60000); // 1 minute connect timeout
          request.setReadTimeout(60000); // 1 minute read timeout
        };

    // Build the client for interacting with the service.
    return new CloudHealthcare.Builder(HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
        .setApplicationName("your-application-name")
        .build();
  }
}

Node.js

Ver en GitHubComentarios

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');

const deleteDicomStore = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth});

  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const dicomStoreId = 'my-dicom-store';
  const name = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/dicomStores/${dicomStoreId}`;
  const request = {name};

  await healthcare.projects.locations.datasets.dicomStores.delete(request);
  console.log(`Deleted DICOM store: ${dicomStoreId}`);
};

deleteDicomStore();

Python

Ver en GitHubComentarios

def delete_dicom_store(project_id, cloud_region, dataset_id, dicom_store_id):
    """Deletes the specified DICOM store."""
    client = get_client()
    dicom_store_parent = "projects/{}/locations/{}/datasets/{}".format(
        project_id, cloud_region, dataset_id
    )
    dicom_store_name = "{}/dicomStores/{}".format(dicom_store_parent, dicom_store_id)

    request = (
        client.projects()
        .locations()
        .datasets()
        .dicomStores()
        .delete(name=dicom_store_name)
    )

    response = request.execute()
    print("Deleted DICOM store: {}".format(dicom_store_id))
    return response

¿Qué sigue?

• Importa y exporta instancias de objetos de DICOM hacia y desde Cloud Storage