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 è in genere un'immagine, ma può essere un altro tipo di dati permanenti come un report strutturato. Un oggetto DICOM in Cloud Storage è un'istanza DICOM che risiede in Cloud Storage. Per ulteriori informazioni, consulta Cloud Storage.

Impostazione delle autorizzazioni Cloud Storage

Prima di esportare e importare i dati DICOM in e da Cloud Storage, devi concedere autorizzazioni aggiuntive all'account di servizio dell'agente di servizio Cloud Healthcare. Per ulteriori informazioni, consulta Autorizzazioni Cloud Storage per gli archivi DICOM.

Importazione degli oggetti DICOM

Per importare diversi file di istanze DICOM in un archivio DICOM, puoi utilizzare 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 i 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 in cui stai 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 che non sono separatori.
      • **: corrisponde a caratteri, inclusi i separatori. Questa estensione può essere utilizzata con un'estensione del nome file in modo che corrisponda a tutti i file 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. Al termine dell'operazione, vengono visualizzate le seguenti indicazioni:
    • La sezione Stato operazione a lunga esecuzione ha un segno di spunta verde sotto l'intestazione OK.
    • La sezione Panoramica contiene un segno di spunta verde e un indicatore OK nella stessa riga dell'ID operazione.
    Se si verificano 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 il comando 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 deve rispettare esattamente il formato specificato nell'esempio seguente.
  • Quando specifichi la posizione degli oggetti DICOM in Cloud Storage, puoi utilizzare i caratteri jolly per importare più file da una o più directory. Sono supportati i seguenti caratteri jolly:
    • Utilizza * per trovare una corrispondenza con zero o più caratteri non separatori. Ad esempio, gs://BUCKET/DIRECTORY/Example*.dcm corrisponde a Example.dcm e Example22.dcm in DIRECTORY.
    • Utilizza ** per trovare corrispondenze di 0 o più caratteri (inclusi i separatori). Deve essere utilizzato alla fine di un percorso e senza altri caratteri jolly. Può essere utilizzato anche con un'estensione di nome file (come .dcm), che importa tutti i file con tale estensione nella directory specificata e nelle relative sottodirectory. Ad esempio, gs://BUCKET/DIRECTORY/**.dcm importa tutti i file con l'estensione .dcm in DIRECTORY e nelle relative sottodirectory.
    • Usa ? per la corrispondenza di 1 carattere. Ad esempio, gs://BUCKET/DIRECTORY/Example?.dcm corrisponde a Example1.dcm, ma non a Example.dcm o Example01.dcm.

Il seguente esempio mostra come importare gli oggetti DICOM da 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 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

Una volta completato il 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 deve necessariamente corrispondere al formato specificato negli esempi seguenti.
  • Quando specifichi la posizione degli oggetti DICOM in Cloud Storage, utilizza i caratteri jolly per importare più file da una o più directory. Sono supportati i seguenti caratteri jolly:
    • Utilizza * per trovare una corrispondenza con zero o più caratteri non separatori. Ad esempio, gs://BUCKET/DIRECTORY/Example*.dcm corrisponde a Example.dcm e Example22.dcm in DIRECTORY.
    • Utilizza ** per trovare corrispondenze di 0 o più caratteri (inclusi i separatori). Deve essere utilizzato alla fine di un percorso e senza altri caratteri jolly. Può essere utilizzato anche con un'estensione di nome file (come .dcm), che importa tutti i file con tale estensione nella directory specificata e nelle relative sottodirectory. Ad esempio, gs://BUCKET/DIRECTORY/**.dcm importa tutti i file con l'estensione .dcm in DIRECTORY e nelle relative sottodirectory.
    • Usa ? per la corrispondenza di 1 carattere. Ad esempio, gs://BUCKET/DIRECTORY/Example?.dcm corrisponde a Example1.dcm, ma non a Example.dcm o Example01.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: il set di dati padre dell'archivio DICOM
    • DICOM_STORE_ID: l'ID archivio 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:

    arricciatura

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

    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 attuale: 

    @'
{
  "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 il completamento delle chiamate al metodo potrebbe richiedere molto tempo. Prendi nota del valore di OPERATION_ID. Questo valore ti servirà 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: il 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:

    arricciatura

    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'LRO, 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, recupera i dati DICOM utilizzando il servizio web RESTful Recupera transazione come 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 un oggetto DICOM in un archivio DICOM con una classe di archiviazione standard. Puoi impostare la classe di archiviazione quando importi oggetti DICOM da Cloud Storage. Per ulteriori informazioni, consulta Modificare la classe di archiviazione DICOM.

I seguenti esempi mostrano come specificare la classe di archiviazione quando importi oggetti DICOM da Cloud Storage.

REST

Utilizza il metodo 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: il set di dati padre dell'archivio DICOM
    • DICOM_STORE_ID: l'ID archivio 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:

    arricciatura

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

    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 attuale: 

    @'
{
  "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 il completamento delle chiamate al metodo potrebbe richiedere molto tempo. Prendi nota del valore di OPERATION_ID. Questo valore ti servirà 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: il 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:

    arricciatura

    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 relativi alle richieste di importazione DICOM

Se si verificano errori durante una richiesta di importazione DICOM, vengono registrati in Cloud Logging. Per maggiori informazioni, consulta 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 questi 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 stai esportando le istanze DICOM.
  3. Nell'elenco dei datastore, scegli Esporta dall'elenco Azioni per l'archivio DICOM.
  4. Nella pagina Esporta archivio DICOM 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 Impostazioni di esportazione DICOM, seleziona il tipo di file utilizzato per esportare le istanze DICOM. Sono disponibili i seguenti tipi:
    • File DICOM (.dcm)
    • Flusso di ottetti
    • Immagine (.jpg, .png)
  8. Per definire la sintassi di trasferimento aggiuntiva, sceglila dall'elenco Sintassi di trasferimento.
  9. Fai clic su Esporta per esportare le istanze DICOM nella località definita in Cloud Storage.
  10. Per monitorare lo stato dell'operazione, fai clic sulla scheda Operazioni. Al termine dell'operazione, vengono visualizzate le seguenti indicazioni:
    • La sezione Stato operazione a lunga esecuzione ha un segno di spunta verde sotto l'intestazione OK.
    • La sezione Panoramica contiene un segno di spunta verde e un indicatore OK nella stessa riga dell'ID operazione.
    Se si verificano 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 il comando gcloud healthcare dicom-stores export gcs.

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

Il seguente esempio mostra il comando 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

Una volta completato il 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 il metodo projects.locations.datasets.dicomStores.export.

  • Scrivi 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, viene creata.

curl

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

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

Il seguente esempio 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 il 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 ha esito positivo, 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 posizione del set di dati padre
  • Il nome dell'archivio DICOM
  • Il bucket Cloud Storage di destinazione

Il seguente esempio 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 il 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 ha esito positivo, 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 delle istanze DICOM utilizzando i filtri

Per impostazione predefinita, quando esporti i file DICOM in Cloud Storage, vengono esportati tutti i file DICOM nell'archivio DICOM. Analogamente, quando esporti i metadati DICOM in BigQuery, vengono esportati i metadati di tutti i dati DICOM nell'archivio DICOM.

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

Configurare un file di filtro

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

Ogni riga del file di 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 oppure un'intera serie specificando /studies/STUDY_INSTANCE_UID/series/SERIES_INSTANCE_UID.

Considera il seguente file di 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 comporta il filtraggio dei seguenti elementi:

  • L'intero studio con l'UID dell'istanza dello studio come 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 nello studio 1.888.999.222 e nella serie 123.456

Creare un file di filtro utilizzando BigQuery

Per creare un file di filtro utilizzando BigQuery, devi esportare i metadati del tuo archivio DICOM in BigQuery. I metadati esportati mostrano lo studio, la serie e gli UID delle istanze dei dati DICOM nel tuo archivio DICOM.

Dopo l'esportazione, completa i seguenti passaggi:

  1. Query sugli 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 gli UID dello studio, della serie e dell'istanza in modo che corrisponda ai requisiti del formato del file di 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 la dimensione massima della risposta, salva i risultati della query in una nuova tabella di destinazione in BigQuery.

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

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

Creare manualmente un file di filtro

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

  1. Crea un file di filtro contenente un elenco di istanze la cui classe di archiviazione deve essere modificata sulla macchina locale. Utilizza il formato descritto nella sezione Configurare il file di 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 di filtro sulla macchina locale
    • FILTER_FILE_NAME: il nome del file 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 passa il file del filtro utilizzando l'API REST. Gli esempi riportati di seguito mostrano come esportare i dati DICOM utilizzando un filtro.

gcloud

Per esportare i metadati DICOM in Cloud Storage utilizzando un filtro, utilizza il comando 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: l'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 le seguenti informazioni:

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

Il seguente esempio 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 formato JSON:

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

La risposta contiene il nome di un'operazione. Utilizza il 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 ha esito positivo, il server restituisce la seguente risposta 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 le seguenti informazioni:

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

Il seguente esempio 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 formato JSON:

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

La risposta contiene il nome di un'operazione. Utilizza il 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 lo 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 relativi alle richieste di esportazione DICOM

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

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