code: def main():
      # parse cmd arguments
      parser = getParser()
      parser.parse_args()
      args = getArguments(parser)
  
      # prepare logger
      logger = Logger.getInstance()
      if args.debug:
          logger.setLevel(logging.DEBUG)
      elif args.verbose:
          logger.setLevel(logging.INFO)
  
      # check if output image exists
      if not args.force:
          if os.path.exists(args.output):
              logger.warning(
                  "The output image {} already exists. Exiting.".format(
                      args.output
                  )
              )
              exit(-1)
  
      # select boundary term
      [
          "diff_linear",
          "diff_exp",
          "diff_div",
          "diff_pow",
          "max_linear",
          "max_exp",
          "max_div",
          "max_pow",
      ]
      if "diff_linear" == args.boundary:
          boundary_term = (
              graphcut.energy_voxel.boundary_difference_linear
          )
          logger.info(
              "Selected boundary term: linear difference of intensities"
          )
      elif "diff_exp" == args.boundary:
          boundary_term = (
              graphcut.energy_voxel.boundary_difference_exponential
          )
          logger.info(
              "Selected boundary term: exponential difference of intensities"
          )
      elif "diff_div" == args.boundary:
          boundary_term = (
              graphcut.energy_voxel.boundary_difference_division
          )
          logger.info(
              "Selected boundary term: divided difference of intensities"
          )
      elif "diff_pow" == args.boundary:
          boundary_term = (
              graphcut.energy_voxel.boundary_difference_power
          )
          logger.info(
              "Selected boundary term: power based / raised difference of intensities"
          )
      elif "max_linear" == args.boundary:
          boundary_term = graphcut.energy_voxel.boundary_maximum_linear
          logger.info(
              "Selected boundary term: linear maximum of intensities"
          )
      elif "max_exp" == args.boundary:
          boundary_term = (
              graphcut.energy_voxel.boundary_maximum_exponential
          )
          logger.info(
              "Selected boundary term: exponential maximum of intensities"
          )
      elif "max_div" == args.boundary:
          boundary_term = (
              graphcut.energy_voxel.boundary_maximum_division
          )
          logger.info(
              "Selected boundary term: divided maximum of intensities"
          )
      elif "max_pow" == args.boundary:
          boundary_term = graphcut.energy_voxel.boundary_maximum_power
          logger.info(
              "Selected boundary term: power based / raised maximum of intensities"
          )
  
      # load input images
      badditional_image_data, reference_header = load(args.badditional)
      markers_image_data, _ = load(args.markers)
  
      # split marker image into fg and bg images
      fgmarkers_image_data, bgmarkers_image_data = split_marker(
          markers_image_data
      )
  
      # check if all images dimensions are the same
      if not (
          badditional_image_data.shape
          == fgmarkers_image_data.shape
          == bgmarkers_image_data.shape
      ):
          logger.critical(
              "Not all of the supplied images are of the same shape."
          )
          raise ArgumentError(
              "Not all of the supplied images are of the same shape."
          )
  
      # extract spacing if required
      if args.spacing:
          spacing = header.get_pixel_spacing(reference_header)
          logger.info(
              "Taking spacing of {} into account.".format(spacing)
          )
      else:
          spacing = False
  
      # generate graph
      logger.info("Preparing BK_MFMC C++ graph...")
      gcgraph = graphcut.graph_from_voxels(
          fgmarkers_image_data,
          bgmarkers_image_data,
          boundary_term=boundary_term,
          boundary_term_args=(
              badditional_image_data,
              args.sigma,
              spacing,
          ),
      )
  
      # execute min-cut
      logger.info("Executing min-cut...")
      maxflow = gcgraph.maxflow()
      logger.debug("Maxflow is {}".format(maxflow))
  
      # reshape results to form a valid mask
      logger.info("Applying results...")
      result_image_data = scipy.zeros(
          bgmarkers_image_data.size, dtype=scipy.bool_
      )
      for idx in range(len(result_image_data)):
          result_image_data[idx] = (
              0
              if gcgraph.termtype.SINK == gcgraph.what_segment(idx)
              else 1
          )
      result_image_data = result_image_data.reshape(
          bgmarkers_image_data.shape
      )
  
      # save resulting mask
      save(
          result_image_data.astype(scipy.bool_),
          args.output,
          reference_header,
          args.force,
      )
  
      logger.info("Successfully terminated.")
  
file_path: medpy/bin/medpy_graphcut_voxel.py
imports: from argparse import RawTextHelpFormatter
  import argparse
  import logging
  import os
  import scipy
  from medpy.core import ArgumentError, Logger
  from medpy.io import load, save, header
  from medpy import graphcut
  from medpy.graphcut.wrapper import split_marker
label_desc: Use image node_id 1 for calling a global function with example usage: main() without return types