Importazione ed esportazione di dati DICOM tramite Cloud Storage

In questa pagina viene spiegato come esportare le istanze DICOM da Cloud Storage e come importarvi oggetti DICOM. Un'istanza DICOM è generalmente un'immagine, ma può un altro tipo di dati permanenti, come i report strutturati. Un oggetto DICOM Cloud Storage è un'istanza DICOM che risiede di archiviazione ideale in Cloud Storage. Per ulteriori informazioni, vedi Cloud Storage.

Impostazione delle autorizzazioni Cloud Storage

Prima di esportare e importare i dati DICOM da e verso Cloud Storage, devi concedere autorizzazioni aggiuntive all'interfaccia Agente di servizio Healthcare account di servizio. Per ulteriori informazioni, vedi Autorizzazioni Cloud Storage per gli archivi DICOM.

Importazione degli oggetti DICOM

Per importare diversi file di istanza DICOM in un archivio DICOM, puoi utilizza uno dei seguenti metodi:

Gli esempi riportati di seguito mostrano come importare gli oggetti DICOM da un bucket Cloud Storage.

Console

Per importare gli oggetti DICOM da un bucket Cloud Storage, completa la seguenti passaggi:

  1. Nella console Google Cloud, vai alla pagina Set di dati.
    Vai a Set di dati
  2. Fai clic sul set di dati che contiene l'archivio DICOM a cui sei importando gli oggetti DICOM.
  3. Nell'elenco dei datastore, scegli Importa dall'elenco Azioni per l'archivio DICOM.

    Viene visualizzata la pagina Importa nell'archivio DICOM.
  4. Nell'elenco Progetto, seleziona un progetto Cloud Storage.
  5. Nell'elenco Località, seleziona un bucket Cloud Storage.
  6. Per impostare una posizione specifica per l'importazione dei file:
    1. Espandi Opzioni avanzate.
    2. Seleziona Override del percorso di Cloud Storage.
    3. Per impostare un'origine specifica per l'importazione dei file, definisci il percorso utilizzando le seguenti variabili nella casella di testo Posizione:
        .
      • *: trova caratteri non separatori.
      • **: trova caratteri, inclusi i separatori. Può essere utilizzata con un'estensione di nome file per trovare corrispondenze di tutti i file di sono dello stesso tipo.
      • ?: corrisponde a 1 carattere.
  7. Fai clic su Importa per importare gli oggetti DICOM dall'origine definita.
  8. Per monitorare lo stato dell'operazione, fai clic sulla scheda Operazioni. Dopo l'operazione vengono visualizzate le seguenti indicazioni:
    • La sezione Stato dell'operazione a lunga esecuzione ha un segno di spunta verde sotto la Intestazione OK.
    • La sezione Panoramica ha un segno di spunta verde e un indicatore OK. nella stessa riga dell'ID operazione.
    In caso di errori, fai clic su Azioni e poi su Visualizza dettagli in Cloud Logging,

gcloud

Per importare gli oggetti DICOM da un bucket Cloud Storage, utilizza gcloud healthcare dicom-stores import gcs . Specifica il nome del set di dati padre, il nome dell'archivio DICOM, e la posizione dell'oggetto in un bucket Cloud Storage.

  • La posizione dei file all'interno del bucket è arbitraria e non è necessario siano conformi esattamente al formato specificato nel seguente esempio.
  • Quando specifichi la posizione degli oggetti DICOM in Cloud Storage, puoi utilizzare caratteri jolly per importare più file da una o più directory. Sono supportati i seguenti caratteri jolly:
    • Utilizza * per trovare una corrispondenza con 0 o più caratteri non separatori. Ad esempio: gs://BUCKET/DIRECTORY/Example*.dcm corrisponde a Example.dcm ed Example22.dcm in DIRECTORY.
    • Utilizza ** per trovare una corrispondenza con 0 o più caratteri (inclusi i separatori). Deve essere utilizzato in alla fine di un percorso e senza altri caratteri jolly nel percorso. Si possono usare anche con un'estensione di nome file (come .dcm), che importa tutti i file con l'estensione del nome file nella directory specificata e nelle relative sottodirectory. Ad esempio, gs://BUCKET/DIRECTORY/**.dcm importa tutti i file con l'estensione .dcm del nome file in DIRECTORY e nelle relative sottodirectory.
    • Usa ? per trovare una corrispondenza con 1 carattere. Ad esempio: gs://BUCKET/DIRECTORY/Example?.dcm corrispondenze Esempio1.dcm ma non corrisponde a Esempio.dcm o Esempio01.dcm.

L'esempio seguente mostra come importare gli oggetti DICOM da un nel 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 riga di comando visualizza l'ID operazione:

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

Per visualizzare lo stato dell'operazione, esegui il comando gcloud healthcare operations describe e fornisci OPERATION_ID dalla risposta:

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

Al termine del comando, la risposta include 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

Per importare gli oggetti DICOM da un bucket Cloud Storage, utilizza il metodo projects.locations.datasets.dicomStores.import.

  • La posizione dei file all'interno del bucket può variare e non è necessario corrispondano al formato specificato nei seguenti esempi.
  • Quando specifichi la posizione degli oggetti DICOM in Cloud Storage, utilizzare caratteri jolly per importare più file da una o più directory. Sono supportati i seguenti caratteri jolly:
    • Utilizza * per trovare una corrispondenza con 0 o più caratteri non separatori. Ad esempio: gs://BUCKET/DIRECTORY/Example*.dcm corrisponde a Example.dcm ed Example22.dcm in DIRECTORY.
    • Utilizza ** per trovare una corrispondenza con 0 o più caratteri (inclusi i separatori). Deve essere utilizzato in alla fine di un percorso e senza altri caratteri jolly nel percorso. Si possono usare anche con un'estensione di nome file (come .dcm), che importa tutti i file con l'estensione del nome file nella directory specificata e nelle relative sottodirectory. Ad esempio, gs://BUCKET/DIRECTORY/**.dcm importa tutti i file con l'estensione .dcm del nome file in DIRECTORY e nelle relative sottodirectory.
    • Usa ? per trovare una corrispondenza con 1 carattere. Ad esempio: gs://BUCKET/DIRECTORY/Example?.dcm corrispondenze Esempio1.dcm ma non corrisponde a Esempio.dcm o Esempio01.dcm.

REST

  1. Importa l'oggetto DICOM.

    Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

    • PROJECT_ID: l'ID del tuo progetto Google Cloud
    • LOCATION: la posizione del set di dati
    • DATASET_ID: set di dati padre dell'archivio DICOM
    • DICOM_STORE_ID: l'ID datastore DICOM
    • BUCKET/PATH/TO/FILE: il percorso dell'oggetto DICOM in Cloud Storage

    Corpo JSON della richiesta: 

    {
  "gcsSource": {
    "uri": "gs://BUCKET/PATH/TO/FILE.dcm"
  }
}

    Per inviare la richiesta, scegli una delle seguenti opzioni:

    curl

    Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

    cat > request.json << 'EOF'
{
  "gcsSource": {
    "uri": "gs://BUCKET/PATH/TO/FILE.dcm"
  }
}
EOF

    Quindi, esegui questo comando per inviare la richiesta REST: 

    curl -X POST \
         -H "Authorization: Bearer $(gcloud auth print-access-token)" \
         -H "Content-Type: application/json" \
         -d @request.json \
         "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:import"

    PowerShell

    Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

    @'
{
  "gcsSource": {
    "uri": "gs://BUCKET/PATH/TO/FILE.dcm"
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

    Quindi, esegui questo comando per inviare la richiesta REST: 

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

    Invoke-WebRequest `
        -Method POST `
        -Headers $headers `
        -ContentType: "application/json" `
        -InFile request.json `
        -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:import" | Select-Object -Expand Content
    L'output è il seguente. La risposta contiene un identificatore per un operazione a lunga esecuzione. Le operazioni a lunga esecuzione vengono restituite quando le chiamate ai metodi possono richiedere un per il completamento. Prendi nota del valore di OPERATION_ID. È necessario questo valore nel passaggio successivo.

  2. Visualizza lo stato dell'operazione a lunga esecuzione.

    Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

    • PROJECT_ID: l'ID del tuo progetto Google Cloud
    • LOCATION: la posizione del set di dati
    • DATASET_ID: set di dati padre dell'archivio DICOM
    • OPERATION_ID: l'ID restituito dall'operazione a lunga esecuzione

    Per inviare la richiesta, scegli una delle seguenti opzioni:

    curl

    Esegui questo comando: 

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

    PowerShell

    Esegui questo comando: 

    $cred = gcloud auth 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
    Se l'operazione a lunga esecuzione è ancora in esecuzione, il server restituisce una risposta con il numero di istanze DICOM in attesa di importazione. Al termine dell'operazione, il server restituisce una risposta con lo stato dell'operazione in formato JSON:

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: %w", 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: %w", 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.gson.GsonFactory;
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 GsonFactory();
  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/healthcare');
const healthcare = google.healthcare({
  version: 'v1',
  auth: new google.auth.GoogleAuth({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  }),
});
const sleep = ms => {
  return new Promise(resolve => setTimeout(resolve, ms));
};

const importDicomInstance = async () => {
  // 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, location, dataset_id, dicom_store_id, content_uri
):
    """Imports data into the DICOM store by copying it from the specified
    source.

    See https://github.com/GoogleCloudPlatform/python-docs-samples/tree/main/healthcare/api-client/v1/dicom
    before running the sample."""
    # Imports the Google API Discovery Service.
    from googleapiclient import discovery

    api_version = "v1"
    service_name = "healthcare"
    # Returns an authorized API client by discovering the Healthcare API
    # and using GOOGLE_APPLICATION_CREDENTIALS environment variable.
    client = discovery.build(service_name, api_version)

    # TODO(developer): Uncomment these lines and replace with your values.
    # project_id = 'my-project'  # replace with your GCP project ID
    # location = 'us-central1'  # replace with the parent dataset's location
    # dataset_id = 'my-dataset'  # replace with the DICOM store's parent dataset ID
    # dicom_store_id = 'my-dicom-store'  # replace with the DICOM store's ID
    # content_uri = 'my-bucket/*.dcm'  # replace with a Cloud Storage bucket and DCM files
    dicom_store_parent = "projects/{}/locations/{}/datasets/{}".format(
        project_id, location, dataset_id
    )
    dicom_store_name = f"{dicom_store_parent}/dicomStores/{dicom_store_id}"

    body = {"gcsSource": {"uri": f"gs://{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(f"Imported DICOM instance: {content_uri}")

    return response

Per recuperare una singola istanza o studio da un archivio DICOM, recuperare dati DICOM utilizzando il pulsante Recupera transazione Servizio web RESTful implementato nell'API Cloud Healthcare.

Specifica una classe di archiviazione per importare gli oggetti DICOM (anteprima)

Per impostazione predefinita, il metodo projects.locations.datasets.dicomStores.import importa a un archivio DICOM con una classe di archiviazione standard. Puoi impostare di archiviazione quando si importano gli oggetti DICOM da Cloud Storage. Per ulteriori informazioni, vedi Modifica la classe di archiviazione DICOM.

I seguenti esempi mostrano come specificare la classe di archiviazione durante l'importazione Oggetti DICOM da Cloud Storage.

REST

Utilizza la projects.locations.datasets.dicomStores.import .

  1. Importa l'oggetto DICOM.

    Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

    • PROJECT_ID: l'ID del tuo progetto Google Cloud
    • LOCATION: la posizione del set di dati
    • DATASET_ID: set di dati padre dell'archivio DICOM
    • DICOM_STORE_ID: l'ID datastore DICOM
    • BUCKET/PATH/TO/FILE: il percorso dell'oggetto DICOM in Cloud Storage
    • STORAGE_CLASS: la classe di archiviazione per l'oggetto DICOM nell'archivio DICOM da STANDARD, NEARLINE, COLDLINE e ARCHIVE

    Corpo JSON della richiesta: 

    {
  "gcsSource": {
    "uri": "gs://BUCKET/PATH/TO/FILE.dcm"
  },
  "blob_storage_settings": {
    "blob_storage_class": "STORAGE_CLASS"
  }
}

    Per inviare la richiesta, scegli una delle seguenti opzioni:

    curl

    Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

    cat > request.json << 'EOF'
{
  "gcsSource": {
    "uri": "gs://BUCKET/PATH/TO/FILE.dcm"
  },
  "blob_storage_settings": {
    "blob_storage_class": "STORAGE_CLASS"
  }
}
EOF

    Quindi, esegui questo comando per inviare la richiesta REST: 

    curl -X POST \
         -H "Authorization: Bearer $(gcloud auth print-access-token)" \
         -H "Content-Type: application/json" \
         -d @request.json \
         "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:import"

    PowerShell

    Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

    @'
{
  "gcsSource": {
    "uri": "gs://BUCKET/PATH/TO/FILE.dcm"
  },
  "blob_storage_settings": {
    "blob_storage_class": "STORAGE_CLASS"
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

    Quindi, esegui questo comando per inviare la richiesta REST: 

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

    Invoke-WebRequest `
        -Method POST `
        -Headers $headers `
        -ContentType: "application/json" `
        -InFile request.json `
        -Uri "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:import" | Select-Object -Expand Content
    L'output è il seguente. La risposta contiene un identificatore per un operazione a lunga esecuzione. Le operazioni a lunga esecuzione vengono restituite quando le chiamate ai metodi possono richiedere un per il completamento. Prendi nota del valore di OPERATION_ID. È necessario questo valore nel passaggio successivo.

  2. Visualizza lo stato dell'operazione a lunga esecuzione.

    Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

    • PROJECT_ID: l'ID del tuo progetto Google Cloud
    • LOCATION: la posizione del set di dati
    • DATASET_ID: set di dati padre dell'archivio DICOM
    • OPERATION_ID: l'ID restituito dall'operazione a lunga esecuzione

    Per inviare la richiesta, scegli una delle seguenti opzioni:

    curl

    Esegui questo comando: 

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

    PowerShell

    Esegui questo comando: 

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

    Invoke-WebRequest `
        -Method GET `
        -Headers $headers `
        -Uri "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID" | Select-Object -Expand Content
    Se l'operazione a lunga esecuzione è ancora in esecuzione, il server restituisce una risposta con il numero di istanze DICOM in attesa di importazione. Al termine dell'LRO, il server restituisce una risposta con lo stato dell'operazione in formato JSON:

Risoluzione dei problemi delle richieste di importazione DICOM

Se si verificano errori durante una richiesta di importazione DICOM, gli errori vengono registrati Cloud Logging. Per ulteriori informazioni, vedi Visualizzazione dei log degli errori in Cloud Logging.

Esportazione delle istanze DICOM

Gli esempi riportati di seguito mostrano come esportare le istanze DICOM in un bucket Cloud Storage. Questa operazione prevede l'esportazione di tutte le istanze nell'archivio DICOM.

Console

Per esportare le istanze DICOM in Cloud Storage, completa quanto segue passaggi:

  1. Nella console Google Cloud, vai alla pagina Set di dati.
    Vai a Set di dati
  2. Fai clic sul set di dati che contiene l'archivio DICOM da cui esportando le istanze DICOM.
  3. Nell'elenco dei datastore, scegli Esporta dal menu a discesa Azioni. per l'archivio DICOM.
  4. Nella pagina Esporta archivio DICOM che viene visualizzata, seleziona Bucket Google Cloud Storage.
  5. Nell'elenco Progetto, seleziona un progetto Cloud Storage.
  6. Nell'elenco Località, seleziona un bucket Cloud Storage.
  7. In DICOM Export Settings (Impostazioni di esportazione DICOM), seleziona il tipo di file utilizzato per l'esportazione delle istanze DICOM. Sono disponibili i seguenti tipi:
    • File DICOM (.dcm)
    • flusso di ottetti
    • Immagine (.jpg, .png)
  8. Per definire la sintassi di trasferimento aggiuntiva, scegli la sintassi dalla Elenco Sintassi di trasferimento.
  9. Fai clic su Esporta per esportare le istanze DICOM nella posizione definita. in Cloud Storage.
  10. Per monitorare lo stato dell'operazione, fai clic sulla scheda Operazioni. Dopo l'operazione vengono visualizzate le seguenti indicazioni:
    • La sezione Stato dell'operazione a lunga esecuzione ha un segno di spunta verde sotto la Intestazione OK.
    • La sezione Panoramica ha un segno di spunta verde e un indicatore OK. nella stessa riga dell'ID operazione.
    In caso di errori, fai clic su Azioni e poi su Visualizza dettagli in Cloud Logging,

gcloud

Per esportare le istanze DICOM in un bucket Cloud Storage, utilizza gcloud healthcare dicom-stores export gcs .

  • Indica il nome del set di dati padre, il nome dell'archivio DICOM e nel bucket Cloud Storage di destinazione.
  • Scrivi in un bucket o in una directory Cloud Storage, anziché in un oggetto, poiché l'API Cloud Healthcare crea un file .dcm per ogni oggetto.
  • Se il comando specifica una directory che non esiste, la directory viene creato.

L'esempio seguente mostra l'elemento 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 riga di comando visualizza l'ID operazione:

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

Per visualizzare lo stato dell'operazione, esegui il comando gcloud healthcare operations describe e fornisci OPERATION_ID dalla risposta:

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

Al termine del comando, la risposta include 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

Per esportare le istanze DICOM in un bucket Cloud Storage, utilizza projects.locations.datasets.dicomStores.export .

  • di scrivere in un bucket o in una directory Cloud Storage, anziché in un oggetto, perché l'API Cloud Healthcare crea un file .dcm per ogni oggetto DICOM.
  • Se il comando specifica una directory che non esiste, la directory viene creato.

curl

Per esportare le istanze DICOM, effettua una richiesta POST e fornisci le seguenti informazioni:

  • Il nome e la località del set di dati padre
  • Nome dell'archivio DICOM
  • Il bucket Cloud Storage di destinazione

L'esempio seguente mostra una richiesta POST che utilizza 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"

Se la richiesta ha esito positivo, il server restituisce la risposta in formato JSON:

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

La risposta contiene il nome di un'operazione. Per monitorare lo stato dell'operazione, utilizza la Metodo dell'operazione 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"

Se la richiesta riesce, il server restituisce una risposta con lo stato dell'operazione in formato 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/query/CLOUD_LOGGING_URL",
    "counter":{
       "success": SUCCESSFUL_INSTANCES
       "failure": FAILED_INSTANCES
    }
  },
  "done": true,
  "response": {
    "@type": "..."
  }
}

PowerShell

Per esportare le istanze DICOM, effettua una richiesta POST e fornisci le seguenti informazioni:

  • Il nome e la località del set di dati padre
  • Nome dell'archivio DICOM
  • Il bucket Cloud Storage di destinazione

L'esempio seguente mostra una richiesta 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" `
  -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

Se la richiesta ha esito positivo, il server restituisce la risposta in formato JSON:

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

La risposta contiene il nome di un'operazione. Per monitorare lo stato dell'operazione, utilizza la Metodo dell'operazione 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

Se la richiesta riesce, il server restituisce una risposta con lo stato dell'operazione in formato 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/query/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: %w", 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: %w", 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.gson.GsonFactory;
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 GsonFactory();
  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/healthcare');
const healthcare = google.healthcare({
  version: 'v1',
  auth: new google.auth.GoogleAuth({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  }),
});

const exportDicomInstanceGcs = async () => {
  // 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, location, dataset_id, dicom_store_id, uri_prefix):
    """Export data to a Google Cloud Storage bucket by copying
    it from the DICOM store.

    See https://github.com/GoogleCloudPlatform/python-docs-samples/tree/main/healthcare/api-client/v1/dicom
    before running the sample."""
    # Imports the Google API Discovery Service.
    from googleapiclient import discovery

    api_version = "v1"
    service_name = "healthcare"
    # Returns an authorized API client by discovering the Healthcare API
    # and using GOOGLE_APPLICATION_CREDENTIALS environment variable.
    client = discovery.build(service_name, api_version)

    # TODO(developer): Uncomment these lines and replace with your values.
    # project_id = 'my-project'  # replace with your GCP project ID
    # location = 'us-central1'  # replace with the parent dataset's location
    # dataset_id = 'my-dataset'  # replace with the DICOM store's parent dataset ID
    # dicom_store_id = 'my-dicom-store'  # replace with the DICOM store's ID
    # uri_prefix = 'my-bucket'  # replace with a Cloud Storage bucket
    dicom_store_parent = "projects/{}/locations/{}/datasets/{}".format(
        project_id, location, dataset_id
    )
    dicom_store_name = f"{dicom_store_parent}/dicomStores/{dicom_store_id}"

    body = {"gcsDestination": {"uriPrefix": f"gs://{uri_prefix}"}}

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

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

    return response

esportazione DICOM istanze utilizzando filtri

Per impostazione predefinita, quando esporti i file DICOM in Cloud Storage, nell'archivio DICOM vengono esportati. Analogamente, quando esporti DICOM metadati a BigQuery, i metadati per tutti i dati DICOM viene esportato l'archivio DICOM.

Puoi esportare un sottoinsieme di dati o metadati DICOM utilizzando un file di filtro.

Configurare un file di filtro

Utilizzando un file filtro puoi definire l'elenco dei file DICOM da esportare in Cloud Storage o BigQuery.

Ogni riga nel file filtro definisce lo studio, la serie o l'istanza e utilizza il formato /studies/STUDY_INSTANCE_UID/series/SERIES_INSTANCE_UID/instances/INSTANCE_UID.

Puoi troncare una riga per specificare il livello a cui funziona il filtro. Ad esempio, puoi esportare un intero studio specificando /studies/STUDY_INSTANCE_UID o puoi esportare un intere serie specificando /studies/STUDY_INSTANCE_UID/series/SERIES_INSTANCE_UID.

Considera il seguente file filtro:

/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

Questo file di filtro restituisce i risultati seguenti:

  • L'intero studio con l'UID dell'istanza di studio 1.123.456.789
  • Due serie separate con UID di istanze di serie come 123.456 e 567.890 nello studio 1.666.333.111
  • Tre singole istanze con ID istanza come 111, 222 e 333 nel studio 1.888.999.222 e serie 123.456

Creare un file di filtro utilizzando BigQuery

Per creare un file filtro utilizzando BigQuery, devi esportare i metadati dell'archivio DICOM in BigQuery. I metadati esportati mostra gli UID di studio, serie e istanza dei dati DICOM nella .

Dopo l'esportazione, completa i seguenti passaggi:

  1. Query per gli UID dello studio, della serie e dell'istanza richiesti.

    Ad esempio, dopo aver esportato i metadati DICOM in BigQuery, esegui la seguente query per concatenare lo studio, la serie e UID dell'istanza in modo che corrispondano ai requisiti del formato file del filtro:

    SELECT CONCAT
    ('/studies/', StudyInstanceUID, '/series/', SeriesInstanceUID, '/instances/', SOPInstanceUID)
FROM
    [PROJECT_ID:BIGQUERY_DATASET.BIGQUERY_TABLE]

  2. (Facoltativo) Se la query restituisce un set di risultati di grandi dimensioni che supera il dimensione massima della risposta, salvare i risultati della query in una nuova tabella di destinazione in BigQuery.

  3. Salva i risultati della query in un ed esportarlo in Cloud Storage. Se hai salvato i risultati della query a una nuova tabella di destinazione nel Passaggio 2, consulta Esportazione dei dati della tabella per esportare i dati della tabella in Cloud Storage.

  4. Modifica il file esportato in base alle esigenze e utilizzalo come file del filtro. La posizione del file del filtro in Cloud Storage è obbligatoria in l'operazione di esportazione.

Creare manualmente un file di filtro

Per creare un file filtro con contenuti personalizzati e caricarlo in un bucket Cloud Storage, completa questi passaggi:

  1. Crea un file filtro contenente un elenco di istanze le cui classi di archiviazione richiedono sul computer locale. Utilizza il formato descritto in Configurare il file del filtro .

  2. Carica il file di testo del filtro in un percorso di Cloud Storage.

    gsutil cp PATH_TO_FILTER_FILE/FILTER_FILE_NAME.txt gs://BUCKET/DIRECTORY

    Sostituisci quanto segue:

    • PATH_TO_FILTER_FILE: il percorso del file del filtro sulla macchina locale
    • FILTER_FILE_NAME: il nome del file del filtro
    • BUCKET/DIRECTORY: il percorso della località di Cloud Storage

    Ad esempio: 

    gsutil cp my-local-folder/archive-filters.txt gs://my-bucket/my-directory

Passaggio nel file di filtro

Dopo aver creato un file di filtro, chiama l'operazione di esportazione DICOM e nel file di filtro utilizzando l'API REST. I seguenti esempi mostrano come per esportare i dati DICOM utilizzando un filtro.

gcloud

Per esportare i metadati DICOM in Cloud Storage utilizzando un filtro, utilizza gcloud beta healthcare dicom-stores export gcs :

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

Sostituisci quanto segue:

  • DICOM_STORE_ID: l'identificatore dell'archivio DICOM
  • DATASET_ID: il nome del set di dati padre dell'archivio DICOM
  • LOCATION: la posizione del set di dati padre dell'archivio DICOM
  • DESTINATION_BUCKET/DIRECTORY: il bucket Cloud Storage di destinazione
  • BUCKET/DIRECTORY/FILTER_FILE: la posizione del file del filtro in un bucket Cloud Storage

L'output è il seguente:

Request issued for: [DICOM_STORE_ID]
Waiting for operation [projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID] to complete...done.
name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID

Per visualizzare lo stato dell'operazione, esegui il comando gcloud healthcare operations describe e fornisci OPERATION_ID dalla risposta:

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

Sostituisci quanto segue:

  • OPERATION_ID: il numero ID restituito dalla risposta precedente
  • DATASET_ID: il nome del set di dati padre dell'archivio DICOM
  • LOCATION: la posizione del set di dati padre dell'archivio DICOM

L'output è il seguente:

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

API

Per esportare i dati DICOM utilizzando un filtro, utilizza il metodo projects.locations.datasets.dicomStores.export.

curl

Per esportare i dati DICOM utilizzando un file di filtro, effettua una richiesta POST e fornisci il metodo le seguenti informazioni:

  • Il nome e la località del set di dati padre
  • Nome dell'archivio DICOM
  • Il bucket Cloud Storage di destinazione
  • La posizione del file del filtro in un bucket Cloud Storage

L'esempio seguente mostra una richiesta POST che utilizza 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"

Se la richiesta ha esito positivo, il server restituisce la seguente risposta in JSON formato:

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

La risposta contiene il nome di un'operazione. Utilizza la Metodo dell'operazione get per monitorare lo stato dell'operazione:

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"

Se la richiesta riesce, il server restituisce la seguente risposta con in Formato 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

Per esportare i dati DICOM utilizzando un file di filtro, effettua una richiesta POST e fornisci il metodo le seguenti informazioni:

  • Il nome e la località del set di dati padre
  • Nome dell'archivio DICOM
  • Il bucket Cloud Storage di destinazione
  • La posizione del file del filtro in un bucket Cloud Storage

L'esempio seguente mostra una richiesta 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" `
  -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

Se la richiesta ha esito positivo, il server restituisce la seguente risposta in JSON formato:

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

La risposta contiene il nome di un'operazione. Utilizza la Metodo dell'operazione get per monitorare lo stato dell'operazione:

$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

Se la richiesta ha esito positivo, il server restituisce la seguente risposta con stato dell'operazione in formato 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": "..."
  }
}

Risoluzione dei problemi delle richieste di esportazione DICOM

Se si verificano errori durante una richiesta di esportazione DICOM, gli errori vengono registrati Cloud Logging. Per ulteriori informazioni, vedi Visualizzazione dei log degli errori in Cloud Logging.

Se l'intera operazione restituisce un errore, consulta la sezione Risoluzione dei problemi relativi alle operazioni a lunga esecuzione.