Cette page a été traduite par l'API Cloud Translation.
Switch to English

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 fournissez les informations suivantes:

  • Nom et emplacement de l'ensemble de données parent
  • Le nom du magasin DICOM
  • L'emplacement des objets dans un bucket Cloud Storage

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 fournissez les informations suivantes:

  • Nom et emplacement de l'ensemble de données parent
  • Le nom du magasin DICOM
  • L'emplacement des objets dans un bucket Cloud Storage

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, puis indiquez les informations suivantes:

  • Nom et emplacement de l'ensemble de données parent
  • Le nom du magasin DICOM
  • Le bucket Cloud Storage de destination

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, puis indiquez les informations suivantes:

  • Nom et emplacement de l'ensemble de données parent
  • Le nom du magasin DICOM
  • Le bucket Cloud Storage de destination

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

Exporter des instances DICOM à l'aide de filtres

Par défaut, lorsque vous exportez des fichiers DICOM vers Cloud Storage, tous les fichiers DICOM du magasin DICOM spécifié sont exportés. De même, lorsque vous exportez des métadonnées DICOM vers BigQuery, les métadonnées de toutes les données DICOM du magasin DICOM spécifié sont exportées.

Vous pouvez exporter un sous-ensemble de données DICOM ou des métadonnées à l'aide d'un filtre. Vous définissez le filtre dans un fichier de filtre.

Configurer des fichiers de filtrage

Un fichier de filtre définit les fichiers DICOM à exporter vers Cloud Storage ou BigQuery. Vous pouvez configurer les fichiers de filtrage aux niveaux suivants:

  • Au niveau de l'étude
  • Au niveau de la série
  • Au niveau de l'instance

Le fichier de filtre est constitué de plusieurs lignes. Chaque ligne définit l'étude, la série ou l'instance que vous souhaitez exporter. Chaque ligne utilise le format /studies/STUDY_UID[/series/SERIES_UID[/instances/INSTANCE_UID]].

Si une étude, une série ou une instance n'est pas spécifiée dans le fichier de filtre lorsque vous transmettez le fichier de filtre, cette étude, cette série ou cette instance ne sera pas exportée.

Seule la partie /studies/STUDY_UID du chemin est obligatoire. Vous pouvez exporter une étude entière en spécifiant /studies/STUDY_UID ou exporter une série entière en spécifiant /studies/STUDY_UID/series/SERIES_UID.

Prenons l'exemple du fichier de filtre suivant : Le fichier de filtre génère une étude, deux séries et trois instances individuelles qui sont exportées:

/studies/1.123.456.789
/studies/1.666.333.111/series/123.456
/studies/1.666.333.111/series/567.890
/studies/1.888.999.222/series/123.456/instances/111
/studies/1.888.999.222/series/123.456/instances/222
/studies/1.888.999.222/series/123.456/instances/333

Créer un fichier de filtre à l'aide de BigQuery

Pour créer un fichier de filtrage, vous devez généralement exporter les métadonnées d'un magasin DICOM vers BigQuery. Cela vous permet d'utiliser BigQuery pour afficher les UID d'étude, de série et d'instance des données DICOM dans votre magasin DICOM. Vous pouvez ensuite effectuer les étapes suivantes:

  1. Demander les UID d'étude, de série et d'instance qui vous intéressent. Par exemple, après avoir exporté des métadonnées DICOM vers BigQuery, vous pouvez exécuter la requête suivante pour concaténer les identifiants UID de l'étude, de la série et de l'instance dans un format compatible avec les exigences de fichier de filtre:
    SELECT CONCAT
        ('/studies/', StudyInstanceUID, '/series/', SeriesInstanceUID, '/instances/', SOPInstanceUID)
    FROM
        [PROJECT_ID:BIGQUERY_DATASET.BIGQUERY_TABLE]
    
  2. Si la requête renvoie un grand ensemble de résultats, vous pouvez matérialiser une nouvelle table en enregistrant les résultats de la requête dans une table de destination dans BigQuery.
  3. Si vous avez enregistré les résultats de la requête dans une table de destination, vous pouvez enregistrer le contenu de la table de destination dans un fichier et l'exporter vers Cloud Storage. Pour obtenir des instructions sur la procédure à suivre, consultez la page Exporter des données de table. Le fichier exporté est votre fichier de filtre. Vous utilisez l'emplacement du fichier de filtre dans Cloud Storage lorsque vous spécifiez le filtre dans l'opération d'exportation.

Créer un fichier de filtre manuellement

Vous pouvez créer un fichier de filtre avec du contenu personnalisé et l'importer dans un bucket Cloud Storage. Vous utilisez l'emplacement du fichier de filtre dans Cloud Storage lorsque vous spécifiez le filtre dans l'opération d'exportation. L'exemple suivant montre comment importer un fichier de filtre dans un bucket Cloud Storage à l'aide de la commande gsutil cp :
gsutil cp PATH/TO/FILTER_FILE gs://BUCKET/DIRECTORY

Transmettre dans le fichier de filtre

Après avoir créé un fichier de filtre, vous pouvez appeler l'opération d'exportation DICOM et transmettre le fichier de filtre à l'aide de l'API REST.

Pour utiliser un fichier de filtre, vous devez saisir le chemin d'accès au fichier dans Cloud Storage dans le champ resourcePathsGcsUri de la commande de l'API REST.

API

Pour exporter des données DICOM à l'aide d'un filtre, utilisez la méthode projects.locations.datasets.dicomStores.export.

curl

Pour exporter des données DICOM à l'aide d'un fichier de filtre, envoyez une requête POST et fournissez les informations suivantes:

  • Nom et emplacement de l'ensemble de données parent
  • Le nom du magasin DICOM
  • Le bucket Cloud Storage de destination
  • L'emplacement du fichier de filtre dans un bucket Cloud Storage

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'
      },
      'filterConfig': {
        'resourcePathsGcsUri': 'gs://BUCKET/DIRECTORY/FILTER_FILE'
      }
    }" "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/REGION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:export"

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

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

La réponse contient un nom d'opération. Vous pouvez suivre l'état de l'opération à l'aide de la méthode Operation get :

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

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

{
  "name": "projects/PROJECT_ID/locations/REGION/datasets/DATASET_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.healthcare.v1beta1.OperationMetadata",
    "apiMethodName": "google.cloud.healthcare.v1beta1.dicom.DicomService.ExportDicomData",
    "createTime": "CREATE_TIME",
    "endTime": "END_TIME"
  },
  "done": true,
  "response": {
    "@type": "..."
  }
}

PowerShell

Pour exporter des données DICOM à l'aide d'un fichier de filtre, envoyez une requête POST et fournissez les informations suivantes:

  • Nom et emplacement de l'ensemble de données parent
  • Le nom du magasin DICOM
  • Le bucket Cloud Storage de destination
  • L'emplacement du fichier de filtre dans un bucket Cloud Storage

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'
    },
    'filterConfig': {
      'resourcePathsGcsUri': 'gs://BUCKET/DIRECTORY/FILTER_FILE'
  }" `
  -Uri "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/REGION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:export" | Select-Object -Expand Content

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

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

La réponse contient un nom d'opération. Vous pouvez suivre l'état de l'opération à l'aide de la méthode Operation get :

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

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

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

{
  "name": "projects/PROJECT_ID/locations/REGION/datasets/DATASET_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.healthcare.v1beta1.OperationMetadata",
    "apiMethodName": "google.cloud.healthcare.v1beta1.dicom.DicomService.ExportDicomData",
    "createTime": "CREATE_TIME",
    "endTime": "END_TIME"
  },
  "done": true,
  "response": {
    "@type": "..."
  }
}

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.