Constructor Detail

• ExportMultilevelTiles

  public ExportMultilevelTiles()

Method Detail

• makePrescaledTiles

  public static Bureaucrat makePrescaledTiles(Layer[] layers,
                                              Class<?> clazz,
                                              Rectangle srcRect,
                                              int c_alphas,
                                              int type,
                                              String target_dir,
                                              int strategy,
                                              Saver saver,
                                              int tileSide,
                                              int directory_structure_type,
                                              boolean skip_empty_tiles,
                                              boolean use_layer_indices,
                                              int n_threads)

  Generate e.g. 256x256 tiles, as many as necessary, to cover the given srcRect, starting at scale 1.0. Designed to be slow but memory-capable. Directory structure types: type 0: filename = z + "/" + row + "_" + column + "_" + s + ".jpg"; type 1: filename = z + "/" + s + "/" + row + "_" + column + ".jpg"; row and column run from 0 to n stepsize 1 that is, row = y / ( 256 * 2^s ) and column = x / ( 256 * 2^s ) z : z-level (slice) x,y: the row and column s: scale, which is 1 / (2^s), in integers: 0, 1, 2 ...  var MAX_S = Math.floor( Math.log( MAX_Y + 1 ) / Math.LN2 ) - Math.floor( Math.log( Y_TILE_SIZE ) / Math.LN2 ) - 1; The module should not be more than 5 At al levels, there should be an even number of rows and columns, except for the coarsest level. The coarsest level should be at least 5x5 tiles. Best results obtained when the srcRect approaches or is a square. Black space will pad the right and bottom edges when the srcRect is not exactly a square. Only the area within the srcRect is ever included, even if actual data exists beyond.

  Parameters:

  strategy - 0 (original images), 1 (mipmaps) or 2 (mipmaps, with multi-layer threading)

  directory_structure_type - 0 or 1. See above.

  skip_empty_tiles - Entirely black tiles will not be written to disk.

  use_layer_indices - The folder for each layer will be that of its index in the LayerSet, which is guaranteed to be unique.

  Returns:

  The watcher thread, for joining purposes, or null if the dialog is canceled or preconditions are not passed.

  Throws:

  IllegalArgumentException - if the type is not ImagePlus.GRAY8 or Imageplus.COLOR_RGB.

• exportFromMipMaps

  public static Worker exportFromMipMaps(TreeMap<Integer,Layer> indices,
                                         int smallestIndex,
                                         String dir,
                                         Saver saver,
                                         Rectangle srcRect,
                                         int c_alphas,
                                         int type,
                                         Class<?> clazz,
                                         int tileSide,
                                         int directory_structure_type,
                                         boolean use_layer_indices,
                                         boolean skip_empty_tiles,
                                         int n_threads)

• exportFromMipMapsLayerWise

  public static Worker exportFromMipMapsLayerWise(TreeMap<Integer,Layer> indices,
                                                  int smallestIndex,
                                                  String dir,
                                                  Saver saver,
                                                  Rectangle srcRect,
                                                  int c_alphas,
                                                  int type,
                                                  Class<?> clazz,
                                                  int tileSide,
                                                  int directory_structure_type,
                                                  boolean use_layer_indices,
                                                  boolean skip_empty_tiles,
                                                  int n_threads)

  When I/O limited, optimize parallel mipmap loading (so that no Thread is waiting on any other Thread to finish loading a mipmap) by generating tiles Patch-wise, processing one Patch at a time, and one Layer per Thread.

• exportFromOriginals

  public static Worker exportFromOriginals(TreeMap<Integer,Layer> indices,
                                           int smallestIndex,
                                           String dir,
                                           Saver saver,
                                           Rectangle srcRect,
                                           int c_alphas,
                                           int type,
                                           Class<?> clazz,
                                           int tileSide,
                                           int directory_structure_type,
                                           boolean use_layer_indices,
                                           boolean skip_empty_tiles,
                                           int n_threads)