cliputil

Lucid CLIP.

This module implements utilities for running CLIP image processing tools.

class cliputil.AABBInfo(xmin: int, ymin: int, zmin: int, xmax: int, ymax: int, zmax: int)

class cliputil.AvgInfo(mean: float, count: int, sum: float)

class cliputil.CAReportLabelInfo(label: int, voxels: int, origin: List[int], extent: List[int])

class cliputil.ComInfo(xcom: float, ycom: float, zcom: float, mass: float)

class cliputil.GluePositionsInfo(global_size: Tuple[int, int], tile_size: Tuple[int, int], tiles: List[cliputil.GlueTilePositionInfo])

class cliputil.GlueTilePositionInfo(tile_path: pathlib.Path, position: Tuple[int, int])

class cliputil.HistoInfo(x0: List[float], pdf: List[float], distr: List[float], total_count: int, bin_counts: List[int])

class cliputil.PopTopInfo(value: float, count: int)

class cliputil.RunTopInfo(quantile: float, count: int, percentile: float)

class cliputil.VarInfo(variance: float, standard_deviation: float)

cliputil.create_empty_file(*args, **kwargs)

For backward compatibility. Use fileioutil instead.

cliputil.extract_raw_pixels_file(image: omni.Image, output_path: pathlib.Path)

Copy the OMNI image pixels to a raw file without offset / trailing data.

cliputil.extract_raw_uint8_pixels_file(image: omni.Image, output_path: pathlib.Path)

Copy and convert the OMNI image pixels to a raw uint8 (or int8) file without offset / trailing data.

cliputil.get_exe_path(*relative_path_components: str) → pathlib.Path

Get path of CLIP executable using environment variable LUCID_CLIP set in installer.

cliputil.get_or_extract_raw_file_and_pipe_float32_pixels(image: omni.Image, temp_folder_path: pathlib.Path) → Tuple[pathlib.Path, List[runutil.PipeProcessInfo]]

Copy and convert the OMNI image pixels to a raw float32 file without offset / trailing data, or just get the existing pixels file if not needed. Return the extracted file path, and the pipe to convert it to float32.

cliputil.get_or_extract_raw_float32_pixels_file(image: omni.Image, temp_folder_path: pathlib.Path) → pathlib.Path

Copy and convert the OMNI image pixels to a raw float32 file without offset / trailing data, or just get the existing pixels file if not needed.

cliputil.get_or_extract_raw_pixels_file(image: omni.Image, output_path: pathlib.Path) → pathlib.Path

Copy the OMNI image pixels to a raw file without offset / trailing data, or just get the existing pixels file if not needed.

cliputil.get_or_extract_raw_uint8_pixels_file(image: omni.Image, temp_folder_path: pathlib.Path) → pathlib.Path

Copy and convert the OMNI image pixels to a raw uint8 (or int8) file without offset / trailing data, or just get the existing pixels file if not needed.

cliputil.optional_env(**kwargs) → Dict[str, str]

Prepare optional environment variables for CLIP.

cliputil.parse_aabb_result(result_text: str) → cliputil.AABBInfo

Parse stdout of CLIP aabb.

Example: xmin 10 ymin 10 zmin 10 xmax 230 ymax 230 zmax 230

cliputil.parse_avg_result(result_text: str) → cliputil.AvgInfo

Parse stdout of CLIP avg.

Example: 11115.8 (250000) 2.77894e+09

cliputil.parse_com_result(result_text: str) → cliputil.ComInfo

Parse stdout of CLIP com.

Example: com 168.35 150.765 46.566 mass 3.21886e+10

cliputil.parse_count_result(result_text: str) → int

Parse stdout of CLIP count.

Example: 143

cliputil.parse_glue_positions_txt(positions_txt_path: pathlib.Path) → cliputil.GluePositionsInfo

Parse positions.txt output of CLIP glue.

Example:

#global image xpixels 24766 ypixels 15045 #tile size xpixels 1024 ypixels 768 tile filename.raw xorigin 321 yorigin 0 …

cliputil.parse_histo_result(result_text: str) → cliputil.HistoInfo

Parse stdout of CLIP histo.

Example:

0.5 0.941976 0.941976 1.5 0 0.941976 2.5 0.0580236 1

#(4.716870e+005) #444318 0 27369

cliputil.parse_poptop_result(result_text: str) → cliputil.PopTopInfo

Parse stdout of CLIP poptop.

Example: 1.533429e+02 (1367184)

cliputil.parse_runtop_result(result_text: str) → cliputil.RunTopInfo

Parse stdout of CLIP runtop.

Example: -1.677722e+07 (250000) 0.000400 percentile

cliputil.parse_var_result(result_text: str) → cliputil.VarInfo

Parse stdout of CLIP var.

Example: 2.658845e+13 std 5.156399e+06

cliputil.pipe_aabb(xsize: int, ysize: int, zsize: int) → runutil.PipeProcessInfo

Prepare CLIP aabb for run_pipe()

cliputil.pipe_and(input2_path: pathlib.Path, *, u32: Optional[bool] = None, not_: Optional[bool] = None) → runutil.PipeProcessInfo

Prepare CLIP and for run_pipe()

cliputil.pipe_aof(input_path: pathlib.Path, xn: int, yn: int) → runutil.PipeProcessInfo

Prepare CLIP aof for run_pipe()

cliputil.pipe_avg() → runutil.PipeProcessInfo

Prepare CLIP avg for run_pipe()

cliputil.pipe_com(xsize: int, ysize: int, zsize: int) → runutil.PipeProcessInfo

Prepare CLIP com for run_pipe()

cliputil.pipe_count() → runutil.PipeProcessInfo

Prepare CLIP count for run_pipe()

cliputil.pipe_curv(output_folder_path: pathlib.Path, xsize: int, ysize: int, *, j0: Optional[int] = None, jn: Optional[int] = None, threshold: Optional[float] = None, dump: Optional[bool] = None, verbose: Optional[float] = None, mirror: Optional[bool] = None, enhance: Optional[bool] = None, dc: Optional[float] = None) → runutil.PipeProcessInfo

Prepare CLIP curv for run_pipe()

cliputil.pipe_down(xn: int, yn: int, *, two_dimensions: bool = False) → runutil.PipeProcessInfo

Prepare CLIP down for run_pipe()

cliputil.pipe_evalp(*, min: Optional[float] = None, max: Optional[float] = None, c0: Optional[float] = None, c1: Optional[float] = None, c2: Optional[float] = None) → runutil.PipeProcessInfo

Prepare CLIP evalp for run_pipe()

cliputil.pipe_f2i(*, inbits: Optional[int] = None, outbits: Optional[int] = None, signed: Optional[bool] = None, min: Optional[float] = None, max: Optional[float] = None, a0: Optional[float] = None, a1: Optional[float] = None) → runutil.PipeProcessInfo

Prepare CLIP f2i for run_pipe()

cliputil.pipe_histo(nbins: int, *, a0: Optional[float] = None, a1: Optional[float] = None) → runutil.PipeProcessInfo

Prepare CLIP histo for run_pipe()

cliputil.pipe_i2f(*, inbits: Optional[int] = None, outbits: Optional[int] = None, signed: Optional[bool] = None, min: Optional[float] = None, max: Optional[float] = None, a0: Optional[float] = None, a1: Optional[float] = None) → runutil.PipeProcessInfo

Prepare CLIP i2f for run_pipe()

cliputil.pipe_lapl(xsize: int, ysize: int, zsize: int) → runutil.PipeProcessInfo

Prepare CLIP lapl for run_pipe()

cliputil.pipe_or(input2_path: pathlib.Path, *, u32: Optional[bool] = None, not_: Optional[bool] = None, xor: Optional[bool] = None) → runutil.PipeProcessInfo

Prepare CLIP or for run_pipe()

cliputil.pipe_pad(xn: int, yn: int, zn: int, xhi: int, yhi: int, zhi: int, *, xlo: Optional[int] = None, ylo: Optional[int] = None, zlo: Optional[int] = None, clamp: Optional[bool] = None) → runutil.PipeProcessInfo

Prepare CLIP pad for run_pipe()

cliputil.pipe_poptop(percent: float, *, down: Optional[bool] = None, sparse: Optional[bool] = None) → runutil.PipeProcessInfo

Prepare CLIP poptop for run_pipe()

cliputil.pipe_putroi(raw_path: pathlib.Path, xsize_source: int, ysize_source: int, zsize_source: int, xstart_roi: int, ystart_roi: int, zstart_roi: int, xsize_roi: int, ysize_roi: int, zsize_roi: int) → runutil.PipeProcessInfo

Prepare CLIP putroi for run_pipe()

cliputil.pipe_roi(raw_path: pathlib.Path, xsize_source: int, ysize_source: int, zsize_source: int, xstart_roi: int, ystart_roi: int, zstart_roi: int, xsize_roi: int, ysize_roi: int, zsize_roi: int, *, offset: Optional[int] = None, element_size: Optional[int] = None) → runutil.PipeProcessInfo

Prepare CLIP roi for run_pipe()

cliputil.pipe_runtop(*, min: Optional[bool] = None) → runutil.PipeProcessInfo

Prepare CLIP runtop for run_pipe()

cliputil.pipe_sel(input2_path: pathlib.Path, *, not_: Optional[bool] = None, dense: Optional[bool] = None, locate: Optional[bool] = None) → runutil.PipeProcessInfo

Prepare CLIP sel for run_pipe()

cliputil.pipe_thr(min: Optional[float] = None, max: Optional[float] = None, *, nrm: Optional[bool] = None, outu8: Optional[bool] = None, bit1: Optional[bool] = None) → runutil.PipeProcessInfo

Prepare CLIP thr for run_pipe()

cliputil.pipe_up(xn: int, yn: int, zn: int) → runutil.PipeProcessInfo

Prepare CLIP up for run_pipe()

cliputil.pipe_var(mean_value: float) → runutil.PipeProcessInfo

Prepare CLIP var for run_pipe()

cliputil.pipe_xyt(xn: int, yn: int, size: int) → runutil.PipeProcessInfo

Prepare CLIP xyt for run_pipe()

cliputil.read_size_file(size_path: pathlib.Path) → List[int]

Read a .size file written by CLIP.

cliputil.run_aabb(input_path: pathlib.Path, xsize: int, ysize: int, zsize: int) → cliputil.AABBInfo

CLIP aabb

cliputil.run_and(input_path: pathlib.Path, input2_path: pathlib.Path, output_path: pathlib.Path, **kwargs)

CLIP and

cliputil.run_aof(input_path: pathlib.Path, output_path: pathlib.Path, xn: int, yn: int)

CLIP aof

cliputil.run_avg(input_path: pathlib.Path) → cliputil.AvgInfo

CLIP avg

cliputil.run_bsp_rotate(input_float32_raw_path: pathlib.Path, output_float32_raw_path: pathlib.Path, xsize: int, ysize: int, yaw_degrees: float, pitch_degrees: float, roll_degrees: float, *, order: Optional[int] = None, ntasks: Optional[int] = None) → Tuple[int, int, int]

CLIP bsp-rotate

Returns the output image size.

cliputil.run_ca(input_int8_raw_path: pathlib.Path, output_labels_path: pathlib.Path, xsize: int, ysize: int, *, d: int = 26, background: Optional[bool] = None, ntasks: Optional[int] = None)

CLIP ca-d6, ca-d18 or ca-d26

cliputil.run_ca_intersected_by_seed(inout_segm_path: pathlib.Path, seed_segm_path: pathlib.Path, tmp_labels_path: pathlib.Path, tmp_sel_path: pathlib.Path, xsize: int, ysize: int, zsize: int, *, d: Optional[int] = None, background: Optional[bool] = None, bit1: Optional[bool] = None)

CLIP ca: select components that intersect with seed segments

cliputil.run_ca_main(inout_segm_path: pathlib.Path, tmp_labels_path: pathlib.Path, xsize: int, ysize: int, *, d: Optional[int] = None, background: Optional[bool] = None, bit1: Optional[bool] = None)

CLIP ca-main.pl

cliputil.run_ca_range(inout_segm_path: pathlib.Path, tmp_labels_path: pathlib.Path, tmp_sel_path: pathlib.Path, xsize: int, ysize: int, *, min_count: Optional[int] = None, max_count: Optional[int] = None, d: Optional[int] = None, background: Optional[bool] = None, bit1: Optional[bool] = None)

CLIP ca select components within pixel count range

cliputil.run_ca_rank(inout_segm_path: pathlib.Path, tmp_labels_path: pathlib.Path, tmp_sel_path: pathlib.Path, xsize: int, ysize: int, *, min_rank: Optional[int] = None, max_rank: Optional[int] = None, d: Optional[int] = None, background: Optional[bool] = None, bit1: Optional[bool] = None)

CLIP ca select components within pixel count rank. (rank=1 is the largest component)

cliputil.run_ca_report(input_labels_path: pathlib.Path, xsize: int, ysize: int, *, ntasks: Optional[int] = None) → List[cliputil.CAReportLabelInfo]

CLIP ca-report

cliputil.run_ca_seld(labels_path: pathlib.Path, selected_txt_path: Optional[pathlib.Path] = None, output_dir_path: Optional[pathlib.Path] = None, *, inout_path: Optional[pathlib.Path] = None, op: Optional[str] = None, not_: Optional[bool] = None, sel_list: Optional[str] = None, bit1: Optional[bool] = None, ntasks: Optional[int] = None)

CLIP ca-seld

cliputil.run_collapse(graph_folder_path: pathlib.Path) → subprocess.CompletedProcess

CLIP collapse

cliputil.run_com(input_path: pathlib.Path, xsize: int, ysize: int, zsize: int) → cliputil.ComInfo

CLIP com

cliputil.run_count(input_uint8_raw_path: pathlib.Path) → int

CLIP count

cliputil.run_curv(input_float_raw_path: pathlib.Path, output_folder_path: pathlib.Path, xsize: int, ysize: int, **kwargs)

CLIP curv

cliputil.run_curv3d(input_float_raw_path: pathlib.Path, output_folder_path: pathlib.Path, xsize: int, ysize: int, *, j0: Optional[int] = None, jn: Optional[int] = None, threshold: Optional[float] = None, dump: Optional[bool] = None, verbose: Optional[float] = None, pad: Optional[int] = None, donuts: Optional[bool] = None, af: Optional[float] = None, fftw_patient: Optional[bool] = None, dc: Optional[float] = None, ntasks: Optional[int] = None)

CLIP curv3d

cliputil.run_dct_rsmpl(input_float_raw_path: pathlib.Path, output_float_raw_path: pathlib.Path, xsize: int, ysize: int, newxsize: int, newysize: int, newzsize: int, ntasks: Optional[int] = None)

CLIP DCT Resampling

cliputil.run_dctf(input_float_raw_path: pathlib.Path, output_folder_path: pathlib.Path, xsize: int, ysize: int, *, nudt: Optional[float] = None, laplace: Optional[int] = None, ntasks: Optional[int] = None)

CLIP DCT Filter

cliputil.run_down(input_path: pathlib.Path, output_path: pathlib.Path, xn: int, yn: int, **kwargs)

CLIP down

cliputil.run_eik(input_seeds_uint8_raw_path: pathlib.Path, input_speed_uint8_raw_path: pathlib.Path, output_folder_path: pathlib.Path, xsize: int, ysize: int, *, minsteps: Optional[int] = None, maxsteps: Optional[int] = None, dt: Optional[float] = None, spd: Optional[int] = None, spr: Optional[int] = None, communication_computation_overlap: Optional[bool] = None, input_ic_path: Optional[pathlib.Path] = None, ntasks: Optional[int] = None)

CLIP eik

cliputil.run_evalp(input_path: pathlib.Path, output_path: pathlib.Path, **kwargs)

CLIP evalp Transform raw float32 values x to y = c0 + c1 * x + c2 * x * x. Optional: First saturate input values to interval [min, max].

cliputil.run_f2i(input_path: pathlib.Path, output_path: pathlib.Path, **kwargs)

CLIP f2i

cliputil.run_gi(input_float_raw_path: pathlib.Path, output_float_raw_path: pathlib.Path, xsize: int, ysize: int, yaw_count: int, pitch_count: int, *, e0: Optional[float] = None, bspline_interpolation: Optional[bool] = None, ntasks: Optional[int] = None)

CLIP GI

cliputil.run_glue(input_list_txt_path: pathlib.Path, output_dir_path: pathlib.Path, tilexcount: int, tilexsize: int, *, invframe: Optional[bool] = None, verbose: Optional[int] = None, overlap: Optional[int] = None, accurate: Optional[bool] = None, ntasks: Optional[int] = None)

CLIP glue

cliputil.run_histo(input_path: pathlib.Path, nbins: int, **kwargs) → cliputil.HistoInfo

CLIP histo

cliputil.run_i2f(input_path: pathlib.Path, output_path: pathlib.Path, **kwargs)

CLIP i2f

cliputil.run_lapl(input_float_raw_path: pathlib.Path, output_float_raw_path: pathlib.Path, xsize: int, ysize: int, zsize: int)

CLIP lapl

cliputil.run_mir(inout_path: pathlib.Path, xn: int, yn: int, el_size: int, axis: str)

CLIP mir

cliputil.run_morph_dilate_erode(inout_int8_raw_path: pathlib.Path, tmp_raw_path: pathlib.Path, xsize: int, ysize: int, margin: float, bit1: Optional[bool] = None)

Use CLIP for morphological operations: * dilate: with margin > 0 * erode: with margin < 0

cliputil.run_morph_open_close(inout_int8_raw_path: pathlib.Path, tmp_raw_path: pathlib.Path, xsize: int, ysize: int, margin: float, bit1: Optional[bool] = None)

Use CLIP for morphological operations: * open: with margin > 0 * close: with margin < 0

cliputil.run_msh_iso(input_float32_raw_path: pathlib.Path, output_mesh_path: pathlib.Path, xsize: int, ysize: int, isovalue: float, *, cap_mesh: bool = True, flip: Optional[bool] = None, input_gi_float32_path: Optional[pathlib.Path] = None, input_aux_float32_path: Optional[pathlib.Path] = None, ntasks: Optional[int] = None)

CLIP msh-iso

cliputil.run_nlf(input_float_raw_path: pathlib.Path, output_folder_path: pathlib.Path, xsize: int, ysize: int, *, a: Optional[float] = None, h: Optional[float] = None, use_lq: bool = False, use_gpu: bool = True)

CLIP Non-Linear Denoising Filter

cliputil.run_or(input_path: pathlib.Path, input2_path: pathlib.Path, output_path: pathlib.Path, **kwargs)

CLIP or

cliputil.run_pad(input_path: pathlib.Path, output_path: pathlib.Path, xn: int, yn: int, zn: int, xhi: int, yhi: int, zhi: int, **kwargs)

CLIP pad

cliputil.run_poptop(input_path: pathlib.Path, percent: float, **kwargs) → cliputil.PopTopInfo

CLIP poptop

cliputil.run_putroi(roi_raw_path: pathlib.Path, **kwargs)

CLIP putroi

cliputil.run_roi(raw_path: pathlib.Path, xsize_source: int, ysize_source: int, zsize_source: int, xstart_roi: int, ystart_roi: int, zstart_roi: int, xsize_roi: int, ysize_roi: int, zsize_roi: int, out_path: pathlib.Path, *, offset: Optional[int] = None, element_size: Optional[int] = None) → subprocess.CompletedProcess

CLIP roi

cliputil.run_runtop(input_path: pathlib.Path, **kwargs) → cliputil.RunTopInfo

CLIP runtop

cliputil.run_sdt(input_path: pathlib.Path, output_path: pathlib.Path, xsize: int, ysize: int, *, all_in_core: Optional[bool] = None, ntasks: Optional[int] = None)

CLIP sdt

cliputil.run_sdt_morph(inout_int8_raw_path: pathlib.Path, tmp_raw_path: pathlib.Path, xsize: int, ysize: int, margin: float, ca: bool = False)

CLIP sdt-morph.pl

cliputil.run_sel(input_path: pathlib.Path, input2_path: pathlib.Path, output_path: pathlib.Path, **kwargs)

CLIP sel

cliputil.run_thk(input_sdt_float32_raw_path: pathlib.Path, output_raw_path: pathlib.Path, xsize: int, ysize: int, *, output_maxthk_txt_path: Optional[pathlib.Path] = None, fine_grained: Optional[bool] = None, ntasks: Optional[int] = None)

CLIP thk

cliputil.run_thn(input_uint8_raw_path: pathlib.Path, output_uint8_raw_path: pathlib.Path, xsize: int, ysize: int, *, median_filt_iter: Optional[int] = None, keep_ends: Optional[bool] = None, read_only_path: Optional[pathlib.Path] = None, ntasks: Optional[int] = None)

CLIP thn

cliputil.run_thr(input_path: pathlib.Path, output_path: pathlib.Path, min: Optional[float] = None, max: Optional[float] = None, **kwargs)

CLIP thr

cliputil.run_thrd(input_path: pathlib.Path, output_path: pathlib.Path, min: Optional[float] = None, max: Optional[float] = None, *, mkdir: Optional[bool] = None, ntasks: Optional[int] = None)

CLIP thrd

cliputil.run_up(input_path: pathlib.Path, output_path: pathlib.Path, xn: int, yn: int, zn: int)

CLIP up

cliputil.run_var(input_path: pathlib.Path, mean_value: float) → cliputil.VarInfo

CLIP var

cliputil.run_vec(skeleton_raw_path: pathlib.Path, sdt_float_raw_path: pathlib.Path, thickness_float_raw_path: pathlib.Path, graph_folder_path: pathlib.Path, xn: int, yn: int) → subprocess.CompletedProcess

CLIP vec

cliputil.run_xyt(input_path: pathlib.Path, output_path: pathlib.Path, xn: int, yn: int, size: int)

CLIP xyt

cliputil.set_file_size(*args, **kwargs)

For backward compatibility. Use fileioutil instead.