How to use the cornerstone-core.displayImage function in cornerstone-core

function(image) {
                console.log(image);
                // 设置元素视口
                var viewport = cornerstone.getDefaultViewportForImage(
                  canvas,
                  image
                );
                // 显示图像
                cornerstone.displayImage(canvas, image, viewport);
                // 激活工具
                _this.initCanvasTools();
              },
              function(err) {

cornerstoneTools.clearToolState(this.element, 'stack');
      cornerstoneTools.addStackStateManager(this.element, [
        'stack',
        'playClip',
        'referenceLines',
      ]);
      cornerstoneTools.addToolState(this.element, 'stack', {
        imageIds: [...imageIds],
        currentImageIdIndex: imageIdIndex,
      });

      // Load first image in stack
      const image = await cornerstone.loadAndCacheImage(imageId);

      // Display
      cornerstone.displayImage(this.element, image);

      if (isStackPrefetchEnabled) {
        _enableStackPrefetching(this.element);
      }

      if (isPlaying) {
        const validFrameRate = Math.max(frameRate, 1);
        cornerstoneTools.playClip(this.element, validFrameRate);
      }

      _addAndConfigureInitialToolsForElement(tools, this.element);
      _trySetActiveTool(this.element, this.props.activeTool);
      this.setState({ isLoading: false });
    } catch (error) {
      this.setState({ error, isLoading: false });
    }

cornerstoneTools.clearToolState(this.element, 'stack');
      cornerstoneTools.addToolState(this.element, 'stack', {
        imageIds: [...stack],
        currentImageIdIndex: imageIndex,
      });

      // New stack; reset counter
      updatedState['numImagesLoaded'] = 0;
      updatedState['error'] = null; // Reset error on new stack

      try {
        // load + display image
        const imageId = stack[imageIndex];
        const image = await cornerstone.loadAndCacheImage(imageId);

        cornerstone.displayImage(this.element, image);
        cornerstone.reset(this.element);
      } catch (err) {
        // :wave:
        // What if user kills component before `displayImage`?
      }
    } else if (!hasStackChanged && hasImageIndexChanged) {
      scrollToIndex(this.element, imageIndex);
    }

    const shouldStopStartStackPrefetch =
      (isStackPrefetchEnabled && hasStackChanged) ||
      (!prevIsStackPrefetchEnabled && isStackPrefetchEnabled === true);

    // Need to stop/start to pickup stack changes in prefetcher
    if (shouldStopStartStackPrefetch) {
      const clear = true;

cornerstone.loadImage(imageId).then((image) => {
        console.log('image --->', image);
        cornerstone.displayImage(element, image);
        if (image) {
          this.setState({ reEnableCornerstoneElement: false });
          visibleCornerstone(true)
        }
      }).catch((e) => {
        console.log('errorsLoadImage --->', e);

dicom_changed: function () {
        var img_bytes = this.model.get('img_bytes');
        console.log('image bytes', img_bytes)
        var img_width = this.model.get('img_width');
        var img_height = this.model.get('img_height');
        var img_min = this.model.get('img_min');
        var img_max = this.model.get('img_max');
        var color = this.model.get('img_color')
        var out_img = this.parse_image(img_bytes, img_width, img_height, img_min, img_max, color);
        cs.enable(this.viewer);
        this.viewport = cs.getDefaultViewportForImage(this.viewer, out_img);
        console.log(out_img);
        cs.displayImage(this.viewer, out_img, this.viewport);
        this._setup_tools();
    },
    _setup_tools: function () {

publicAPI.renderBlankImage = () => {
    if (!model.container) {
      return;
    }
    cornerstone.displayImage(model.container, BLANK_IMAGE);
  };

cornerstone.loadImage(enabledElement.image.imageId).then(image => {
            cornerstone.displayImage(viewportElement, image);
            cornerstone.setViewport(viewportElement, viewport);
            cornerstone.resize(viewportElement, true);

            const newWidth = Math.min(width || image.width, MAX_TEXTURE_SIZE);
            const newHeight = Math.min(
              height || image.height,
              MAX_TEXTURE_SIZE
            );

            resolve({ image, width: newWidth, height: newHeight });
          });
        }

);
        }

        Object.assign(viewport, {
          voi: {
            windowWidth: model.representation.getColorWindow(),
            windowCenter: model.representation.getColorLevel(),
          },
          hflip: model.representation.getHFlip(),
          vflip: model.representation.getVFlip(),
          pixelReplication: !model.representation.getInterpolation(),
          invert: model.representation.getInvertColors(),
          rotation: model.rotateAngle,
        });

        cornerstone.displayImage(model.container, image, viewport);
      })
      .catch((error) => vtkErrorMacro(String(error)));