Importer et exporter des données DICOM à l'aide de Cloud Storage

Cette page explique comment importer des objets DICOM depuis Cloud Storage et comment y exporter des instances DICOM. Une instance DICOM est généralement une image, mais il peut s'agir d'un autre type de données persistantes, par exemple un rapport structuré. Un objet Cloud Storage est une instance DICOM qui réside dans Cloud Storage.

Vous pouvez importer et exporter des données groupées entre un bucket Cloud Storage et un datastore DICOM. Par exemple, vous pouvez importer de nombreux fichiers d'instance DICOM dans un datastore DICOM. Plutôt que de stocker les données par programmation directement, vous pouvez les stocker dans un bucket Cloud Storage, puis importer les fichiers dans un datastore DICOM au moyen d'une seule opération d'importation. Pour en savoir plus, consultez la page Cloud Storage.

Pour stocker une instance DICOM directement, par exemple à partir de votre ordinateur local, vous pouvez stocker les données DICOM à l'aide du service Web RESTful Store Transaction mis en œuvre dans l'API Cloud Healthcare. Pour récupérer une seule instance ou étude à partir d'un datastore DICOM, vous pouvez récupérer des données DICOM à l'aide du service Web RESTful Retrieve Transaction mis en œuvre dans l'API Cloud Healthcare.

Définir des autorisations Cloud Storage

Avant d'importer des données DICOM depuis Cloud Storage ou de les exporter vers ce service, vous devez accorder des autorisations supplémentaires au compte de service Agent de service Cloud Healthcare. Pour en savoir plus, consultez la section Autorisations Cloud Storage pour les datastores DICOM.

Importer des objets DICOM

Les exemples suivants montrent comment importer des objets DICOM depuis un bucket Cloud Storage.

Console

Pour importer des objets DICOM à partir d'un bucket Cloud Storage, procédez comme suit :

  1. Dans Cloud Console, accédez à la page Ensembles de données.

    Accéder à la page Ensembles de données

  2. Cliquez sur l'ensemble de données pour lequel vous importez des objets DICOM.

  3. Dans la liste des magasins DICOM, choisissez Importer dans la liste Actions.

    La page Importer dans le magasin DICOM s'affiche.

  4. Dans la liste Projet, sélectionnez un projet Cloud Storage.

  5. Dans la liste Emplacement, sélectionnez un bucket Cloud Storage.

  6. Pour définir un emplacement spécifique pour l'importation de fichiers, procédez comme suit :

    1. Développer les options avancées
    2. Sélectionnez Remplacer le chemin d'accès Cloud Storage.
    3. Pour définir une source spécifique pour l'importation de fichiers, définissez le chemin d'accès à l'aide des variables suivantes dans la zone de texte Emplacement :
      • * - correspond aux caractères non séparateurs.
      • ** - correspond aux caractères, y compris les séparateurs. Cela peut être utilisé avec une extension de nom de fichier pour correspondre à tous les fichiers du même type.
      • ? - correspond à 1 caractère.
  7. Cliquez sur Importer pour importer des objets DICOM à partir de la source définie.

gcloud

Pour importer des objets DICOM à partir d'un bucket Cloud Storage, utilisez la commande gcloud healthcare dicom-stores import gcs. Spécifiez le nom de l'ensemble de données parent, le nom du magasin DICOM et l'emplacement de l'objet dans un bucket Cloud Storage.

  • L'emplacement des fichiers dans le bucket est arbitraire et ne doit pas nécessairement respecter exactement le format spécifié dans l'exemple suivant.
  • Lorsque vous spécifiez l'emplacement des objets DICOM dans Cloud Storage, vous pouvez importer plusieurs fichiers depuis un ou plusieurs répertoires au moyen de caractères génériques. Les caractères génériques suivants sont acceptés :
    • Utilisez * pour correspondre à 0 ou plusieurs caractères non séparateurs. Par exemple, gs://BUCKET/DIRECTORY/Example*.dcm correspond à Example.dcm et Example22.dcm dans DIRECTORY.
    • Utilisez ** pour correspondre à 0 caractère ou plus (séparateurs compris). Doit être utilisé à la fin d'un chemin d'accès et sans autres caractères génériques. Peut également être utilisé avec une extension de nom de fichier (.dcm, par exemple), qui importe tous les fichiers portant l'extension dans le répertoire spécifié et ses sous-répertoires. Par exemple, gs://BUCKET/DIRECTORY/**.dcm importe tous les fichiers portant l'extension .dcm dans DIRECTORY et ses sous-répertoires.
    • Utilisez ? pour correspondre à 1 caractère. Par exemple, gs://BUCKET/DIRECTORY/Example?.dcm correspond à "Example1.dcm", mais ne correspond pas à "Example.dcm" ou "Example01.dcm".

L'exemple suivant montre comment importer des objets DICOM à partir d'un bucket Cloud Storage.

gcloud healthcare dicom-stores import gcs DICOM_STORE_ID \
  --dataset=DATASET_ID \
  --location=LOCATION \
  --gcs-uri=gs://BUCKET/DIRECTORY/DICOM_INSTANCE.dcm

La ligne de commande affiche l'ID de l'opération :

name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID

Pour afficher l'état de l'opération, exécutez la commande gcloud healthcare operations describe en fournissant le OPERATION_ID spécifié dans la réponse :

gcloud healthcare operations describe OPERATION_ID \
  --location=LOCATION \
  --dataset=DATASET_ID

Une fois la commande terminée, la réponse inclut done: true.

done: true
metadata:
'@type': type.googleapis.com/google.cloud.healthcare.v1.OperationMetadata
apiMethodName: google.cloud.healthcare.v1.dicom.DicomService.ImportDicomData
counter:
  success: SUCCESSFUL_INSTANCES
  failure: FAILED_INSTANCES
createTime: "CREATE_TIME"
endTime: "END_TIME"
name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID
response:
'@type': "..."

API

Pour importer des objets DICOM à partir d'un bucket Cloud Storage, utilisez la méthode projects.locations.datasets.dicomStores.import.

  • L'emplacement des fichiers dans le bucket est arbitraire et ne doit pas nécessairement respecter exactement le format spécifié dans les exemples suivants.
  • Lorsque vous spécifiez l'emplacement des objets DICOM dans Cloud Storage, vous pouvez importer plusieurs fichiers depuis un ou plusieurs répertoires au moyen de caractères génériques. Les caractères génériques suivants sont acceptés :
    • Utilisez * pour correspondre à 0 ou plusieurs caractères non séparateurs. Par exemple, gs://BUCKET/DIRECTORY/Example*.dcm correspond à Example.dcm et Example22.dcm dans DIRECTORY.
    • Utilisez ** pour correspondre à 0 caractère ou plus (séparateurs compris). Doit être utilisé à la fin d'un chemin d'accès et sans autres caractères génériques. Peut également être utilisé avec une extension de nom de fichier (.dcm, par exemple), qui importe tous les fichiers portant l'extension dans le répertoire spécifié et ses sous-répertoires. Par exemple, gs://BUCKET/DIRECTORY/**.dcm importe tous les fichiers portant l'extension .dcm dans DIRECTORY et ses sous-répertoires.
    • Utilisez ? pour correspondre à 1 caractère. Par exemple, gs://BUCKET/DIRECTORY/Example?.dcm correspond à "Example1.dcm", mais ne correspond pas à "Example.dcm" ou "Example01.dcm".

curl

Pour importer des objets DICOM, envoyez une requête POST, et indiquez le nom de l'ensemble de données parent, le nom du datastore DICOM, l'emplacement de l'objet dans un bucket Cloud Storage et un jeton d'accès.

L'exemple suivant montre une requête POST utilisant curl.

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    --data "{
      'gcsSource': {
        'uri': 'gs://BUCKET/*.dcm'
      }
    }" "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:import"

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID"
}

La réponse contient un nom d'opération. Pour suivre l'état de l'opération, vous pouvez utiliser la méthode get :

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/operations/OPERATION_ID"

Si la requête aboutit, le serveur renvoie une réponse avec l'état de l'opération au format JSON :

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.healthcare.v1.OperationMetadata",
    "apiMethodName": "google.cloud.healthcare.v1.dicom.DicomService.ImportDicomData",
    "createTime": "CREATE_TIME",
    "endTime": "END_TIME",
    "logsUrl": "https://console.cloud.google.com/logs/viewer/CLOUD_LOGGING_URL",
    "counter": {
       "success": SUCCESSFUL_INSTANCES
       "failure": FAILED_INSTANCES
    },
  },
  "done": true,
  "response": {
    "@type": "..."
  }
}

PowerShell

Pour importer des objets DICOM, envoyez une requête POST, et indiquez le nom de l'ensemble de données parent, le nom du datastore DICOM, l'emplacement de l'objet dans un bucket Cloud Storage et un jeton d'accès.

L'exemple suivant montre une requête POST utilisant 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" `
  -Body "{
    'gcsSource': {
      'uri': 'gs://BUCKET/*.dcm'
    }
  }" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:import" | Select-Object -Expand Content

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID"
}

La réponse contient un nom d'opération. Pour suivre l'état de l'opération, vous pouvez utiliser la méthode get :

$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/operations/OPERATION_ID" | Select-Object -Expand Content

Si la requête aboutit, le serveur renvoie une réponse avec l'état de l'opération au format JSON :

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.healthcare.v1.OperationMetadata",
    "apiMethodName": "google.cloud.healthcare.v1.dicom.DicomService.ImportDicomData",
    "createTime": "CREATE_TIME",
    "endTime": "END_TIME",
    "logsUrl": "https://console.cloud.google.com/logs/viewer/CLOUD_LOGGING_URL",
    "counter":{
       "success": SUCCESSFUL_INSTANCES
       "failure": FAILED_INSTANCES
    }
  },
  "done": true,
  "response": {
    "@type": "..."
  }
}

Go

import (
	"context"
	"fmt"
	"io"

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

// importDICOMInstance imports DICOM objects from GCS.
func importDICOMInstance(w io.Writer, projectID, location, datasetID, dicomStoreID, contentURI 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

	req := &healthcare.ImportDicomDataRequest{
		GcsSource: &healthcare.GoogleCloudHealthcareV1DicomGcsSource{
			Uri: contentURI,
		},
	}
	name := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/dicomStores/%s", projectID, location, datasetID, dicomStoreID)

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

	fmt.Fprintf(w, "Import to DICOM store started. Operation: %q\n", lro.Name)
	return nil
}

Java

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.GoogleCloudHealthcareV1DicomGcsSource;
import com.google.api.services.healthcare.v1.model.ImportDicomDataRequest;
import com.google.api.services.healthcare.v1.model.Operation;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;

public class DicomStoreImport {
  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 dicomStoreImport(String dicomStoreName, String gcsUri) throws IOException {
    // String dicomStoreName =
    //    String.format(
    //        DICOM_NAME, "your-project-id", "your-region-id", "your-dataset-id", "your-dicom-id");
    // String gcsUri = "gs://your-bucket-id/path/to/destination/dir"

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

    // Configure where the store should be imported from.
    GoogleCloudHealthcareV1DicomGcsSource gcsSource =
        new GoogleCloudHealthcareV1DicomGcsSource().setUri(gcsUri);
    ImportDicomDataRequest importRequest = new ImportDicomDataRequest().setGcsSource(gcsSource);

    // Create request and configure any parameters.
    DicomStores.CloudHealthcareImport request =
        client
            .projects()
            .locations()
            .datasets()
            .dicomStores()
            .healthcareImport(dicomStoreName, importRequest);

    // Execute the request, wait for the operation to complete, and process the results.
    try {
      Operation operation = request.execute();
      while (operation.getDone() == null || !operation.getDone()) {
        // Update the status of the operation with another request.
        Thread.sleep(500); // Pause for 500ms between requests.
        operation =
            client
                .projects()
                .locations()
                .datasets()
                .operations()
                .get(operation.getName())
                .execute();
      }
      System.out.println("DICOM store import complete." + operation.getResponse());
    } catch (Exception ex) {
      System.out.printf("Error during request execution: %s", ex.toString());
      ex.printStackTrace(System.out);
    }
  }

  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

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

const importDicomInstance = 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 gcsUri = 'my-bucket/my-directory/*.dcm'
  const name = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/dicomStores/${dicomStoreId}`;
  const request = {
    name,
    resource: {
      // The location of the DICOM instances in Cloud Storage
      gcsSource: {
        uri: `gs://${gcsUri}`,
      },
    },
  };

  const operation = await healthcare.projects.locations.datasets.dicomStores.import(
    request
  );
  const operationName = operation.data.name;

  const operationRequest = {name: operationName};

  // Wait fifteen seconds for the LRO to finish.
  await sleep(15000);

  // Check the LRO's status
  const operationStatus = await healthcare.projects.locations.datasets.operations.get(
    operationRequest
  );

  const {data} = operationStatus;

  if (data.error === undefined) {
    console.log('Successfully imported DICOM instances');
  } else {
    console.log('Encountered errors. Sample error:');
    console.log(
      'Resource on which error occured:',
      data.error.details[0]['sampleErrors'][0]['resource']
    );
    console.log(
      'Error code:',
      data.error.details[0]['sampleErrors'][0]['error']['code']
    );
    console.log(
      'Error message:',
      data.error.details[0]['sampleErrors'][0]['error']['message']
    );
  }
};

importDicomInstance();

Python

def import_dicom_instance(
    project_id, cloud_region, dataset_id, dicom_store_id, content_uri
):
    """Import data into the DICOM store by copying it from the specified
    source.
    """
    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)

    body = {"gcsSource": {"uri": "gs://{}".format(content_uri)}}

    # Escape "import()" method keyword because "import"
    # is a reserved keyword in Python
    request = (
        client.projects()
        .locations()
        .datasets()
        .dicomStores()
        .import_(name=dicom_store_name, body=body)
    )

    response = request.execute()
    print("Imported DICOM instance: {}".format(content_uri))

    return response

Résoudre les problèmes liés aux requêtes d'importation DICOM

Si des erreurs se produisent lors d'une requête d'importation DICOM, elles sont consignées dans Cloud Logging. Pour en savoir plus, consultez la section Afficher les journaux d'erreurs dans Cloud Logging.

Exporter des instances DICOM

Les exemples suivants montrent comment exporter des instances DICOM vers un bucket Cloud Storage. Lorsque vous exportez des instances DICOM depuis un datastore DICOM, toutes les instances qu'il contient sont exportées.

Console

Pour exporter des instances DICOM vers Cloud Storage, procédez comme suit :

  1. Dans Cloud Console, accédez à la page Ensembles de données.

    Accéder à la page Ensembles de données

  2. Cliquez sur l'ensemble de données pour lequel vous exportez des instances DICOM.

  3. Dans la liste des magasins DICOM, choisissez Exporter dans la liste Actions.

    La page Exporter un magasin DICOM s'affiche.

  4. Sélectionnez Bucket Google Cloud Storage.

  5. Dans la liste Projet, sélectionnez un projet Cloud Storage.

  6. Dans la liste Emplacement, sélectionnez un bucket Cloud Storage.

  7. Dans Paramètres d'exportation DICOM, sélectionnez le type de fichier utilisé pour exporter les instances DICOM. Les types suivants sont disponibles :

    • Fichier DICOM (.dcm)
    • Octetstream
    • Image (.jpg, .png)
  8. Pour définir une syntaxe de transfert supplémentaire, sélectionnez-la dans la liste Syntaxe de transfert.

  9. Cliquez sur Exporter pour exporter des instances DICOM vers l'emplacement défini dans Cloud Storage.

gcloud

Pour exporter des instances DICOM vers un bucket Cloud Storage, utilisez la commande gcloud healthcare dicom-stores export gcs.

  • Indiquez le nom de l'ensemble de données parent, le nom du magasin DICOM et le bucket Cloud Storage de destination.
  • Écrivez dans un bucket ou un répertoire Cloud Storage plutôt qu'un objet, car l'API Cloud Healthcare crée un fichier .dcm pour chaque objet.
  • Si la commande spécifie un répertoire qui n'existe pas, celui-ci est créé.

L'exemple suivant montre la commande gcloud healthcare dicom-stores export gcs.

gcloud healthcare dicom-stores export gcs DICOM_STORE_ID \
  --dataset=DATASET_ID \
  --location=LOCATION \
  --gcs-uri-prefix=gs://BUCKET/DIRECTORY

La ligne de commande affiche l'ID de l'opération :

name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID

Pour afficher l'état de l'opération, exécutez la commande gcloud healthcare operations describe en fournissant le OPERATION_ID spécifié dans la réponse :

gcloud healthcare operations describe OPERATION_ID \
  --location=LOCATION \
  --dataset=DATASET_ID

Une fois la commande terminée, la réponse inclut done: true.

done: true
metadata:
'@type': type.googleapis.com/google.cloud.healthcare.v1.OperationMetadata
apiMethodName: google.cloud.healthcare.v1.dicom.DicomService.ExportDicomData
counter:
  success: SUCCESSFUL_INSTANCES
  failure: FAILED_INSTANCES
createTime: "CREATE_TIME"
endTime: "END_TIME"
name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID
response:
'@type': "..."

API

Pour exporter des instances DICOM vers un bucket Cloud Storage, utilisez la méthode projects.locations.datasets.dicomStores.export.

  • Écrivez dans un bucket ou un répertoire Cloud Storage plutôt qu'un objet, car l'API Cloud Healthcare crée un fichier .dcm pour chaque objet DICOM.
  • Si la commande spécifie un répertoire qui n'existe pas, celui-ci est créé.

curl

Pour exporter des instances DICOM, envoyez une requête POST, et indiquez le nom de l'ensemble de données parent, le nom du datastore DICOM, le bucket Cloud Storage de destination et un jeton d'accès.

L'exemple suivant montre une requête POST utilisant curl.

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

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID"
}

La réponse contient un nom d'opération. Pour suivre l'état de l'opération, vous pouvez utiliser la méthode get :

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/operations/OPERATION_ID"

Si la requête aboutit, le serveur renvoie une réponse avec l'état de l'opération au format JSON :

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.healthcare.v1.OperationMetadata",
    "apiMethodName": "google.cloud.healthcare.v1.dicom.DicomService.ExportDicomData",
    "createTime": "CREATE_TIME",
    "endTime": "END_TIME",
    "logsUrl": "https://console.cloud.google.com/logs/viewer/CLOUD_LOGGING_URL",
    "counter":{
       "success": SUCCESSFUL_INSTANCES
       "failure": FAILED_INSTANCES
    }
  },
  "done": true,
  "response": {
    "@type": "..."
  }
}

PowerShell

Pour exporter des instances DICOM, envoyez une requête POST, et indiquez le nom de l'ensemble de données parent, le nom du datastore DICOM, le bucket Cloud Storage de destination et un jeton d'accès.

L'exemple suivant montre une requête POST utilisant 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" `
  -Body "{
    'gcsDestination': {
      'uriPrefix': 'gs://BUCKET/DIRECTORY'
    }
  }" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:export" | Select-Object -Expand Content

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID"
}

La réponse contient un nom d'opération. Pour suivre l'état de l'opération, vous pouvez utiliser la méthode get :

$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/operations/OPERATION_ID" | Select-Object -Expand Content

Si la requête aboutit, le serveur renvoie une réponse avec l'état de l'opération au format JSON :

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.healthcare.v1.OperationMetadata",
    "apiMethodName": "google.cloud.healthcare.v1.dicom.DicomService.ExportDicomData",
    "createTime": "CREATE_TIME",
    "endTime": "END_TIME",
    "logsUrl": "https://console.cloud.google.com/logs/viewer/CLOUD_LOGGING_URL",
    "counter":{
       "success": SUCCESSFUL_INSTANCES
       "failure": FAILED_INSTANCES
    },
  },
  "done": true,
  "response": {
    "@type": "..."
  }
}

Go

import (
	"context"
	"fmt"
	"io"

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

// exportDICOMInstance exports DICOM objects to GCS.
func exportDICOMInstance(w io.Writer, projectID, location, datasetID, dicomStoreID, destination 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

	req := &healthcare.ExportDicomDataRequest{
		GcsDestination: &healthcare.GoogleCloudHealthcareV1DicomGcsDestination{
			UriPrefix: destination, // "gs://my-bucket/path/to/prefix/"
		},
	}
	name := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/dicomStores/%s", projectID, location, datasetID, dicomStoreID)

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

	fmt.Fprintf(w, "Export to DICOM store started. Operation: %q\n", lro.Name)
	return nil
}

Java

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.ExportDicomDataRequest;
import com.google.api.services.healthcare.v1.model.GoogleCloudHealthcareV1DicomGcsDestination;
import com.google.api.services.healthcare.v1.model.Operation;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;

public class DicomStoreExport {
  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 dicomStoreExport(String dicomStoreName, String gcsUri) throws IOException {
    // String dicomStoreName =
    //    String.format(
    //        DICOM_NAME, "your-project-id", "your-region-id", "your-dataset-id", "your-dicom-id");
    // String gcsUri = "gs://your-bucket-id/path/to/destination/dir"

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

    // Configure where the store will be exported too.
    GoogleCloudHealthcareV1DicomGcsDestination gcsDestination =
        new GoogleCloudHealthcareV1DicomGcsDestination().setUriPrefix(gcsUri);
    ExportDicomDataRequest exportRequest =
        new ExportDicomDataRequest().setGcsDestination(gcsDestination);

    // Create request and configure any parameters.
    DicomStores.Export request =
        client
            .projects()
            .locations()
            .datasets()
            .dicomStores()
            .export(dicomStoreName, exportRequest);

    // Execute the request, wait for the operation to complete, and process the results.
    try {
      Operation operation = request.execute();
      while (operation.getDone() == null || !operation.getDone()) {
        // Update the status of the operation with another request.
        Thread.sleep(500); // Pause for 500ms between requests.
        operation =
            client
                .projects()
                .locations()
                .datasets()
                .operations()
                .get(operation.getName())
                .execute();
      }
      System.out.println("DICOM store export complete." + operation.getResponse());
    } catch (Exception ex) {
      System.out.printf("Error during request execution: %s", ex.toString());
      ex.printStackTrace(System.out);
    }
  }

  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

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

const exportDicomInstanceGcs = 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 gcsUri = 'my-bucket/my-directory'
  const name = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/dicomStores/${dicomStoreId}`;
  const request = {
    name,
    resource: {
      gcsDestination: {
        // The destination location of the DICOM instances in Cloud Storage
        uriPrefix: `gs://${gcsUri}`,
        // The format to use for the output files, per the MIME types supported in the DICOM spec
        mimeType: 'application/dicom',
      },
    },
  };

  await healthcare.projects.locations.datasets.dicomStores.export(request);
  console.log(`Exported DICOM instances to ${gcsUri}`);
};

exportDicomInstanceGcs();

Python

def export_dicom_instance(
    project_id, cloud_region, dataset_id, dicom_store_id, uri_prefix
):
    """Export data to a Google Cloud Storage bucket by copying
    it from 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)

    body = {"gcsDestination": {"uriPrefix": "gs://{}".format(uri_prefix)}}

    request = (
        client.projects()
        .locations()
        .datasets()
        .dicomStores()
        .export(name=dicom_store_name, body=body)
    )

    response = request.execute()
    print("Exported DICOM instances to bucket: gs://{}".format(uri_prefix))

    return response

Résoudre les problèmes liés aux requêtes d'exportation DICOM

Si des erreurs se produisent lors d'une requête d'exportation DICOM, elles sont consignées dans Cloud Logging. Pour en savoir plus, consultez la section Afficher les journaux d'erreurs dans Cloud Logging.