Datasets:

renish1

/

custom-code

like 0

[ "def", "fill_from_augmented_normalized_batch", "(", "self", ",", "batch_aug_norm", ")", ":", "# we take here the .data from the normalized batch instead of from", "# self for the rare case where one has decided to somehow change it", "# during augmentation", "batch", "=", "UnnormalizedBatch", "(", "images", "=", "self", ".", "images_unaug", ",", "heatmaps", "=", "self", ".", "heatmaps_unaug", ",", "segmentation_maps", "=", "self", ".", "segmentation_maps_unaug", ",", "keypoints", "=", "self", ".", "keypoints_unaug", ",", "bounding_boxes", "=", "self", ".", "bounding_boxes_unaug", ",", "polygons", "=", "self", ".", "polygons_unaug", ",", "line_strings", "=", "self", ".", "line_strings_unaug", ",", "data", "=", "batch_aug_norm", ".", "data", ")", "batch", ".", "images_aug", "=", "nlib", ".", "invert_normalize_images", "(", "batch_aug_norm", ".", "images_aug", ",", "self", ".", "images_unaug", ")", "batch", ".", "heatmaps_aug", "=", "nlib", ".", "invert_normalize_heatmaps", "(", "batch_aug_norm", ".", "heatmaps_aug", ",", "self", ".", "heatmaps_unaug", ")", "batch", ".", "segmentation_maps_aug", "=", "nlib", ".", "invert_normalize_segmentation_maps", "(", "batch_aug_norm", ".", "segmentation_maps_aug", ",", "self", ".", "segmentation_maps_unaug", ")", "batch", ".", "keypoints_aug", "=", "nlib", ".", "invert_normalize_keypoints", "(", "batch_aug_norm", ".", "keypoints_aug", ",", "self", ".", "keypoints_unaug", ")", "batch", ".", "bounding_boxes_aug", "=", "nlib", ".", "invert_normalize_bounding_boxes", "(", "batch_aug_norm", ".", "bounding_boxes_aug", ",", "self", ".", "bounding_boxes_unaug", ")", "batch", ".", "polygons_aug", "=", "nlib", ".", "invert_normalize_polygons", "(", "batch_aug_norm", ".", "polygons_aug", ",", "self", ".", "polygons_unaug", ")", "batch", ".", "line_strings_aug", "=", "nlib", ".", "invert_normalize_line_strings", "(", "batch_aug_norm", ".", "line_strings_aug", ",", "self", ".", "line_strings_unaug", ")", "return", "batch" ]

[ "Fill", "this", "batch", "with", "(", "normalized", ")", "augmentation", "results", "." ]

[ "def", "Positive", "(", "other_param", ",", "mode", "=", "\"invert\"", ",", "reroll_count_max", "=", "2", ")", ":", "return", "ForceSign", "(", "other_param", "=", "other_param", ",", "positive", "=", "True", ",", "mode", "=", "mode", ",", "reroll_count_max", "=", "reroll_count_max", ")" ]

[ "Converts", "another", "parameter", "s", "results", "to", "positive", "values", "." ]

[ "def", "Negative", "(", "other_param", ",", "mode", "=", "\"invert\"", ",", "reroll_count_max", "=", "2", ")", ":", "return", "ForceSign", "(", "other_param", "=", "other_param", ",", "positive", "=", "False", ",", "mode", "=", "mode", ",", "reroll_count_max", "=", "reroll_count_max", ")" ]

[ "Converts", "another", "parameter", "s", "results", "to", "negative", "values", "." ]

[ "def", "create_for_noise", "(", "other_param", ",", "threshold", "=", "(", "-", "10", ",", "10", ")", ",", "activated", "=", "True", ")", ":", "return", "Sigmoid", "(", "other_param", ",", "threshold", ",", "activated", ",", "mul", "=", "20", ",", "add", "=", "-", "10", ")" ]

[ "Creates", "a", "Sigmoid", "that", "is", "adjusted", "to", "be", "used", "with", "noise", "parameters", "i", ".", "e", ".", "with", "parameters", "which", "s", "output", "values", "are", "in", "the", "range", "[", "0", ".", "0", "1", ".", "0", "]", "." ]

[ "def", "area", "(", "self", ")", ":", "if", "len", "(", "self", ".", "exterior", ")", "<", "3", ":", "raise", "Exception", "(", "\"Cannot compute the polygon's area because it contains less than three points.\"", ")", "poly", "=", "self", ".", "to_shapely_polygon", "(", ")", "return", "poly", ".", "area" ]

[ "Estimate", "the", "area", "of", "the", "polygon", "." ]

[ "def", "project", "(", "self", ",", "from_shape", ",", "to_shape", ")", ":", "if", "from_shape", "[", "0", ":", "2", "]", "==", "to_shape", "[", "0", ":", "2", "]", ":", "return", "self", ".", "copy", "(", ")", "ls_proj", "=", "self", ".", "to_line_string", "(", "closed", "=", "False", ")", ".", "project", "(", "from_shape", ",", "to_shape", ")", "return", "self", ".", "copy", "(", "exterior", "=", "ls_proj", ".", "coords", ")" ]

[ "Project", "the", "polygon", "onto", "an", "image", "with", "different", "shape", "." ]

[ "def", "find_closest_point_index", "(", "self", ",", "x", ",", "y", ",", "return_distance", "=", "False", ")", ":", "ia", ".", "do_assert", "(", "len", "(", "self", ".", "exterior", ")", ">", "0", ")", "distances", "=", "[", "]", "for", "x2", ",", "y2", "in", "self", ".", "exterior", ":", "d", "=", "(", "x2", "-", "x", ")", "**", "2", "+", "(", "y2", "-", "y", ")", "**", "2", "distances", ".", "append", "(", "d", ")", "distances", "=", "np", ".", "sqrt", "(", "distances", ")", "closest_idx", "=", "np", ".", "argmin", "(", "distances", ")", "if", "return_distance", ":", "return", "closest_idx", ",", "distances", "[", "closest_idx", "]", "return", "closest_idx" ]

[ "Find", "the", "index", "of", "the", "point", "within", "the", "exterior", "that", "is", "closest", "to", "the", "given", "coordinates", "." ]

[ "def", "is_fully_within_image", "(", "self", ",", "image", ")", ":", "return", "not", "self", ".", "is_out_of_image", "(", "image", ",", "fully", "=", "True", ",", "partly", "=", "True", ")" ]

[ "Estimate", "whether", "the", "polygon", "is", "fully", "inside", "the", "image", "area", "." ]

[ "def", "is_partly_within_image", "(", "self", ",", "image", ")", ":", "return", "not", "self", ".", "is_out_of_image", "(", "image", ",", "fully", "=", "True", ",", "partly", "=", "False", ")" ]

[ "Estimate", "whether", "the", "polygon", "is", "at", "least", "partially", "inside", "the", "image", "area", "." ]

[ "def", "is_out_of_image", "(", "self", ",", "image", ",", "fully", "=", "True", ",", "partly", "=", "False", ")", ":", "# TODO this is inconsistent with line strings, which return a default", "# value in these cases", "if", "len", "(", "self", ".", "exterior", ")", "==", "0", ":", "raise", "Exception", "(", "\"Cannot determine whether the polygon is inside the image, because it contains no points.\"", ")", "ls", "=", "self", ".", "to_line_string", "(", ")", "return", "ls", ".", "is_out_of_image", "(", "image", ",", "fully", "=", "fully", ",", "partly", "=", "partly", ")" ]

[ "Estimate", "whether", "the", "polygon", "is", "partially", "or", "fully", "outside", "of", "the", "image", "area", "." ]

[ "def", "clip_out_of_image", "(", "self", ",", "image", ")", ":", "# load shapely lazily, which makes the dependency more optional", "import", "shapely", ".", "geometry", "# if fully out of image, clip everything away, nothing remaining", "if", "self", ".", "is_out_of_image", "(", "image", ",", "fully", "=", "True", ",", "partly", "=", "False", ")", ":", "return", "[", "]", "h", ",", "w", "=", "image", ".", "shape", "[", "0", ":", "2", "]", "if", "ia", ".", "is_np_array", "(", "image", ")", "else", "image", "[", "0", ":", "2", "]", "poly_shapely", "=", "self", ".", "to_shapely_polygon", "(", ")", "poly_image", "=", "shapely", ".", "geometry", ".", "Polygon", "(", "[", "(", "0", ",", "0", ")", ",", "(", "w", ",", "0", ")", ",", "(", "w", ",", "h", ")", ",", "(", "0", ",", "h", ")", "]", ")", "multipoly_inter_shapely", "=", "poly_shapely", ".", "intersection", "(", "poly_image", ")", "if", "not", "isinstance", "(", "multipoly_inter_shapely", ",", "shapely", ".", "geometry", ".", "MultiPolygon", ")", ":", "ia", ".", "do_assert", "(", "isinstance", "(", "multipoly_inter_shapely", ",", "shapely", ".", "geometry", ".", "Polygon", ")", ")", "multipoly_inter_shapely", "=", "shapely", ".", "geometry", ".", "MultiPolygon", "(", "[", "multipoly_inter_shapely", "]", ")", "polygons", "=", "[", "]", "for", "poly_inter_shapely", "in", "multipoly_inter_shapely", ".", "geoms", ":", "polygons", ".", "append", "(", "Polygon", ".", "from_shapely", "(", "poly_inter_shapely", ",", "label", "=", "self", ".", "label", ")", ")", "# shapely changes the order of points, we try here to preserve it as", "# much as possible", "polygons_reordered", "=", "[", "]", "for", "polygon", "in", "polygons", ":", "found", "=", "False", "for", "x", ",", "y", "in", "self", ".", "exterior", ":", "closest_idx", ",", "dist", "=", "polygon", ".", "find_closest_point_index", "(", "x", "=", "x", ",", "y", "=", "y", ",", "return_distance", "=", "True", ")", "if", "dist", "<", "1e-6", ":", "polygon_reordered", "=", "polygon", ".", "change_first_point_by_index", "(", "closest_idx", ")", "polygons_reordered", ".", "append", "(", "polygon_reordered", ")", "found", "=", "True", "break", "ia", ".", "do_assert", "(", "found", ")", "# could only not find closest points if new polys are empty", "return", "polygons_reordered" ]

[ "Cut", "off", "all", "parts", "of", "the", "polygon", "that", "are", "outside", "of", "the", "image", "." ]

[ "def", "shift", "(", "self", ",", "top", "=", "None", ",", "right", "=", "None", ",", "bottom", "=", "None", ",", "left", "=", "None", ")", ":", "ls_shifted", "=", "self", ".", "to_line_string", "(", "closed", "=", "False", ")", ".", "shift", "(", "top", "=", "top", ",", "right", "=", "right", ",", "bottom", "=", "bottom", ",", "left", "=", "left", ")", "return", "self", ".", "copy", "(", "exterior", "=", "ls_shifted", ".", "coords", ")" ]

[ "Shift", "the", "polygon", "from", "one", "or", "more", "image", "sides", "i", ".", "e", ".", "move", "it", "on", "the", "x", "/", "y", "-", "axis", "." ]

[ "def", "draw_on_image", "(", "self", ",", "image", ",", "color", "=", "(", "0", ",", "255", ",", "0", ")", ",", "color_face", "=", "None", ",", "color_lines", "=", "None", ",", "color_points", "=", "None", ",", "alpha", "=", "1.0", ",", "alpha_face", "=", "None", ",", "alpha_lines", "=", "None", ",", "alpha_points", "=", "None", ",", "size", "=", "1", ",", "size_lines", "=", "None", ",", "size_points", "=", "None", ",", "raise_if_out_of_image", "=", "False", ")", ":", "assert", "color", "is", "not", "None", "assert", "alpha", "is", "not", "None", "assert", "size", "is", "not", "None", "color_face", "=", "color_face", "if", "color_face", "is", "not", "None", "else", "np", ".", "array", "(", "color", ")", "color_lines", "=", "color_lines", "if", "color_lines", "is", "not", "None", "else", "np", ".", "array", "(", "color", ")", "*", "0.5", "color_points", "=", "color_points", "if", "color_points", "is", "not", "None", "else", "np", ".", "array", "(", "color", ")", "*", "0.5", "alpha_face", "=", "alpha_face", "if", "alpha_face", "is", "not", "None", "else", "alpha", "*", "0.5", "alpha_lines", "=", "alpha_lines", "if", "alpha_lines", "is", "not", "None", "else", "alpha", "alpha_points", "=", "alpha_points", "if", "alpha_points", "is", "not", "None", "else", "alpha", "size_lines", "=", "size_lines", "if", "size_lines", "is", "not", "None", "else", "size", "size_points", "=", "size_points", "if", "size_points", "is", "not", "None", "else", "size", "*", "3", "if", "image", ".", "ndim", "==", "2", ":", "assert", "ia", ".", "is_single_number", "(", "color_face", ")", ",", "(", "\"Got a 2D image. Expected then 'color_face' to be a single \"", "\"number, but got %s.\"", "%", "(", "str", "(", "color_face", ")", ",", ")", ")", "color_face", "=", "[", "color_face", "]", "elif", "image", ".", "ndim", "==", "3", "and", "ia", ".", "is_single_number", "(", "color_face", ")", ":", "color_face", "=", "[", "color_face", "]", "*", "image", ".", "shape", "[", "-", "1", "]", "if", "alpha_face", "<", "0.01", ":", "alpha_face", "=", "0", "elif", "alpha_face", ">", "0.99", ":", "alpha_face", "=", "1", "if", "raise_if_out_of_image", "and", "self", ".", "is_out_of_image", "(", "image", ")", ":", "raise", "Exception", "(", "\"Cannot draw polygon %s on image with shape %s.\"", "%", "(", "str", "(", "self", ")", ",", "image", ".", "shape", ")", ")", "# TODO np.clip to image plane if is_fully_within_image(), similar to how it is done for bounding boxes", "# TODO improve efficiency by only drawing in rectangle that covers poly instead of drawing in the whole image", "# TODO for a rectangular polygon, the face coordinates include the top/left boundary but not the right/bottom", "# boundary. This may be unintuitive when not drawing the boundary. Maybe somehow remove the boundary", "# coordinates from the face coordinates after generating both?", "input_dtype", "=", "image", ".", "dtype", "result", "=", "image", ".", "astype", "(", "np", ".", "float32", ")", "rr", ",", "cc", "=", "skimage", ".", "draw", ".", "polygon", "(", "self", ".", "yy_int", ",", "self", ".", "xx_int", ",", "shape", "=", "image", ".", "shape", ")", "if", "len", "(", "rr", ")", ">", "0", ":", "if", "alpha_face", "==", "1", ":", "result", "[", "rr", ",", "cc", "]", "=", "np", ".", "float32", "(", "color_face", ")", "elif", "alpha_face", "==", "0", ":", "pass", "else", ":", "result", "[", "rr", ",", "cc", "]", "=", "(", "(", "1", "-", "alpha_face", ")", "*", "result", "[", "rr", ",", "cc", ",", ":", "]", "+", "alpha_face", "*", "np", ".", "float32", "(", "color_face", ")", ")", "ls_open", "=", "self", ".", "to_line_string", "(", "closed", "=", "False", ")", "ls_closed", "=", "self", ".", "to_line_string", "(", "closed", "=", "True", ")", "result", "=", "ls_closed", ".", "draw_lines_on_image", "(", "result", ",", "color", "=", "color_lines", ",", "alpha", "=", "alpha_lines", ",", "size", "=", "size_lines", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", "result", "=", "ls_open", ".", "draw_points_on_image", "(", "result", ",", "color", "=", "color_points", ",", "alpha", "=", "alpha_points", ",", "size", "=", "size_points", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", "if", "input_dtype", ".", "type", "==", "np", ".", "uint8", ":", "result", "=", "np", ".", "clip", "(", "np", ".", "round", "(", "result", ")", ",", "0", ",", "255", ")", ".", "astype", "(", "input_dtype", ")", "# TODO make clipping more flexible", "else", ":", "result", "=", "result", ".", "astype", "(", "input_dtype", ")", "return", "result" ]

[ "Draw", "the", "polygon", "on", "an", "image", "." ]

[ "def", "extract_from_image", "(", "self", ",", "image", ")", ":", "ia", ".", "do_assert", "(", "image", ".", "ndim", "in", "[", "2", ",", "3", "]", ")", "if", "len", "(", "self", ".", "exterior", ")", "<=", "2", ":", "raise", "Exception", "(", "\"Polygon must be made up of at least 3 points to extract its area from an image.\"", ")", "bb", "=", "self", ".", "to_bounding_box", "(", ")", "bb_area", "=", "bb", ".", "extract_from_image", "(", "image", ")", "if", "self", ".", "is_out_of_image", "(", "image", ",", "fully", "=", "True", ",", "partly", "=", "False", ")", ":", "return", "bb_area", "xx", "=", "self", ".", "xx_int", "yy", "=", "self", ".", "yy_int", "xx_mask", "=", "xx", "-", "np", ".", "min", "(", "xx", ")", "yy_mask", "=", "yy", "-", "np", ".", "min", "(", "yy", ")", "height_mask", "=", "np", ".", "max", "(", "yy_mask", ")", "width_mask", "=", "np", ".", "max", "(", "xx_mask", ")", "rr_face", ",", "cc_face", "=", "skimage", ".", "draw", ".", "polygon", "(", "yy_mask", ",", "xx_mask", ",", "shape", "=", "(", "height_mask", ",", "width_mask", ")", ")", "mask", "=", "np", ".", "zeros", "(", "(", "height_mask", ",", "width_mask", ")", ",", "dtype", "=", "np", ".", "bool", ")", "mask", "[", "rr_face", ",", "cc_face", "]", "=", "True", "if", "image", ".", "ndim", "==", "3", ":", "mask", "=", "np", ".", "tile", "(", "mask", "[", ":", ",", ":", ",", "np", ".", "newaxis", "]", ",", "(", "1", ",", "1", ",", "image", ".", "shape", "[", "2", "]", ")", ")", "return", "bb_area", "*", "mask" ]

[ "Extract", "the", "image", "pixels", "within", "the", "polygon", "." ]

[ "def", "change_first_point_by_coords", "(", "self", ",", "x", ",", "y", ",", "max_distance", "=", "1e-4", ",", "raise_if_too_far_away", "=", "True", ")", ":", "if", "len", "(", "self", ".", "exterior", ")", "==", "0", ":", "raise", "Exception", "(", "\"Cannot reorder polygon points, because it contains no points.\"", ")", "closest_idx", ",", "closest_dist", "=", "self", ".", "find_closest_point_index", "(", "x", "=", "x", ",", "y", "=", "y", ",", "return_distance", "=", "True", ")", "if", "max_distance", "is", "not", "None", "and", "closest_dist", ">", "max_distance", ":", "if", "not", "raise_if_too_far_away", ":", "return", "self", ".", "deepcopy", "(", ")", "closest_point", "=", "self", ".", "exterior", "[", "closest_idx", ",", ":", "]", "raise", "Exception", "(", "\"Closest found point (%.9f, %.9f) exceeds max_distance of %.9f exceeded\"", "%", "(", "closest_point", "[", "0", "]", ",", "closest_point", "[", "1", "]", ",", "closest_dist", ")", ")", "return", "self", ".", "change_first_point_by_index", "(", "closest_idx", ")" ]

[ "Set", "the", "first", "point", "of", "the", "exterior", "to", "the", "given", "point", "based", "on", "its", "coordinates", "." ]

[ "def", "change_first_point_by_index", "(", "self", ",", "point_idx", ")", ":", "ia", ".", "do_assert", "(", "0", "<=", "point_idx", "<", "len", "(", "self", ".", "exterior", ")", ")", "if", "point_idx", "==", "0", ":", "return", "self", ".", "deepcopy", "(", ")", "exterior", "=", "np", ".", "concatenate", "(", "(", "self", ".", "exterior", "[", "point_idx", ":", ",", ":", "]", ",", "self", ".", "exterior", "[", ":", "point_idx", ",", ":", "]", ")", ",", "axis", "=", "0", ")", "return", "self", ".", "deepcopy", "(", "exterior", "=", "exterior", ")" ]

[ "Set", "the", "first", "point", "of", "the", "exterior", "to", "the", "given", "point", "based", "on", "its", "index", "." ]

[ "def", "to_shapely_polygon", "(", "self", ")", ":", "# load shapely lazily, which makes the dependency more optional", "import", "shapely", ".", "geometry", "return", "shapely", ".", "geometry", ".", "Polygon", "(", "[", "(", "point", "[", "0", "]", ",", "point", "[", "1", "]", ")", "for", "point", "in", "self", ".", "exterior", "]", ")" ]

[ "Convert", "this", "polygon", "to", "a", "Shapely", "polygon", "." ]

[ "def", "to_shapely_line_string", "(", "self", ",", "closed", "=", "False", ",", "interpolate", "=", "0", ")", ":", "return", "_convert_points_to_shapely_line_string", "(", "self", ".", "exterior", ",", "closed", "=", "closed", ",", "interpolate", "=", "interpolate", ")" ]

[ "Convert", "this", "polygon", "to", "a", "Shapely", "LineString", "object", "." ]

[ "def", "to_bounding_box", "(", "self", ")", ":", "# TODO get rid of this deferred import", "from", "imgaug", ".", "augmentables", ".", "bbs", "import", "BoundingBox", "xx", "=", "self", ".", "xx", "yy", "=", "self", ".", "yy", "return", "BoundingBox", "(", "x1", "=", "min", "(", "xx", ")", ",", "x2", "=", "max", "(", "xx", ")", ",", "y1", "=", "min", "(", "yy", ")", ",", "y2", "=", "max", "(", "yy", ")", ",", "label", "=", "self", ".", "label", ")" ]

[ "Convert", "this", "polygon", "to", "a", "bounding", "box", "tightly", "containing", "the", "whole", "polygon", "." ]

[ "def", "to_keypoints", "(", "self", ")", ":", "# TODO get rid of this deferred import", "from", "imgaug", ".", "augmentables", ".", "kps", "import", "Keypoint", "return", "[", "Keypoint", "(", "x", "=", "point", "[", "0", "]", ",", "y", "=", "point", "[", "1", "]", ")", "for", "point", "in", "self", ".", "exterior", "]" ]

[ "Convert", "this", "polygon", "s", "exterior", "to", "Keypoint", "instances", "." ]

[ "def", "to_line_string", "(", "self", ",", "closed", "=", "True", ")", ":", "from", "imgaug", ".", "augmentables", ".", "lines", "import", "LineString", "if", "not", "closed", "or", "len", "(", "self", ".", "exterior", ")", "<=", "1", ":", "return", "LineString", "(", "self", ".", "exterior", ",", "label", "=", "self", ".", "label", ")", "return", "LineString", "(", "np", ".", "concatenate", "(", "[", "self", ".", "exterior", ",", "self", ".", "exterior", "[", "0", ":", "1", ",", ":", "]", "]", ",", "axis", "=", "0", ")", ",", "label", "=", "self", ".", "label", ")" ]

[ "Convert", "this", "polygon", "s", "exterior", "to", "a", "LineString", "instance", "." ]

[ "def", "from_shapely", "(", "polygon_shapely", ",", "label", "=", "None", ")", ":", "# load shapely lazily, which makes the dependency more optional", "import", "shapely", ".", "geometry", "ia", ".", "do_assert", "(", "isinstance", "(", "polygon_shapely", ",", "shapely", ".", "geometry", ".", "Polygon", ")", ")", "# polygon_shapely.exterior can be None if the polygon was instantiated without points", "if", "polygon_shapely", ".", "exterior", "is", "None", "or", "len", "(", "polygon_shapely", ".", "exterior", ".", "coords", ")", "==", "0", ":", "return", "Polygon", "(", "[", "]", ",", "label", "=", "label", ")", "exterior", "=", "np", ".", "float32", "(", "[", "[", "x", ",", "y", "]", "for", "(", "x", ",", "y", ")", "in", "polygon_shapely", ".", "exterior", ".", "coords", "]", ")", "return", "Polygon", "(", "exterior", ",", "label", "=", "label", ")" ]

[ "Create", "a", "polygon", "from", "a", "Shapely", "polygon", "." ]

[ "def", "exterior_almost_equals", "(", "self", ",", "other", ",", "max_distance", "=", "1e-6", ",", "points_per_edge", "=", "8", ")", ":", "if", "isinstance", "(", "other", ",", "list", ")", ":", "other", "=", "Polygon", "(", "np", ".", "float32", "(", "other", ")", ")", "elif", "ia", ".", "is_np_array", "(", "other", ")", ":", "other", "=", "Polygon", "(", "other", ")", "else", ":", "assert", "isinstance", "(", "other", ",", "Polygon", ")", "other", "=", "other", "return", "self", ".", "to_line_string", "(", "closed", "=", "True", ")", ".", "coords_almost_equals", "(", "other", ".", "to_line_string", "(", "closed", "=", "True", ")", ",", "max_distance", "=", "max_distance", ",", "points_per_edge", "=", "points_per_edge", ")" ]

[ "Estimate", "if", "this", "and", "other", "polygon", "s", "exterior", "are", "almost", "identical", "." ]

[ "def", "almost_equals", "(", "self", ",", "other", ",", "max_distance", "=", "1e-6", ",", "points_per_edge", "=", "8", ")", ":", "if", "not", "isinstance", "(", "other", ",", "Polygon", ")", ":", "return", "False", "if", "self", ".", "label", "is", "not", "None", "or", "other", ".", "label", "is", "not", "None", ":", "if", "self", ".", "label", "is", "None", ":", "return", "False", "if", "other", ".", "label", "is", "None", ":", "return", "False", "if", "self", ".", "label", "!=", "other", ".", "label", ":", "return", "False", "return", "self", ".", "exterior_almost_equals", "(", "other", ",", "max_distance", "=", "max_distance", ",", "points_per_edge", "=", "points_per_edge", ")" ]

[ "Estimate", "if", "this", "polygon", "s", "and", "another", "s", "geometry", "/", "labels", "are", "similar", "." ]

[ "def", "copy", "(", "self", ",", "exterior", "=", "None", ",", "label", "=", "None", ")", ":", "return", "self", ".", "deepcopy", "(", "exterior", "=", "exterior", ",", "label", "=", "label", ")" ]

[ "Create", "a", "shallow", "copy", "of", "the", "Polygon", "object", "." ]

[ "def", "deepcopy", "(", "self", ",", "exterior", "=", "None", ",", "label", "=", "None", ")", ":", "return", "Polygon", "(", "exterior", "=", "np", ".", "copy", "(", "self", ".", "exterior", ")", "if", "exterior", "is", "None", "else", "exterior", ",", "label", "=", "self", ".", "label", "if", "label", "is", "None", "else", "label", ")" ]

[ "Create", "a", "deep", "copy", "of", "the", "Polygon", "object", "." ]

[ "def", "on", "(", "self", ",", "image", ")", ":", "shape", "=", "normalize_shape", "(", "image", ")", "if", "shape", "[", "0", ":", "2", "]", "==", "self", ".", "shape", "[", "0", ":", "2", "]", ":", "return", "self", ".", "deepcopy", "(", ")", "polygons", "=", "[", "poly", ".", "project", "(", "self", ".", "shape", ",", "shape", ")", "for", "poly", "in", "self", ".", "polygons", "]", "# TODO use deepcopy() here", "return", "PolygonsOnImage", "(", "polygons", ",", "shape", ")" ]

[ "Project", "polygons", "from", "one", "image", "to", "a", "new", "one", "." ]

[ "def", "draw_on_image", "(", "self", ",", "image", ",", "color", "=", "(", "0", ",", "255", ",", "0", ")", ",", "color_face", "=", "None", ",", "color_lines", "=", "None", ",", "color_points", "=", "None", ",", "alpha", "=", "1.0", ",", "alpha_face", "=", "None", ",", "alpha_lines", "=", "None", ",", "alpha_points", "=", "None", ",", "size", "=", "1", ",", "size_lines", "=", "None", ",", "size_points", "=", "None", ",", "raise_if_out_of_image", "=", "False", ")", ":", "for", "poly", "in", "self", ".", "polygons", ":", "image", "=", "poly", ".", "draw_on_image", "(", "image", ",", "color", "=", "color", ",", "color_face", "=", "color_face", ",", "color_lines", "=", "color_lines", ",", "color_points", "=", "color_points", ",", "alpha", "=", "alpha", ",", "alpha_face", "=", "alpha_face", ",", "alpha_lines", "=", "alpha_lines", ",", "alpha_points", "=", "alpha_points", ",", "size", "=", "size", ",", "size_lines", "=", "size_lines", ",", "size_points", "=", "size_points", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", "return", "image" ]

[ "Draw", "all", "polygons", "onto", "a", "given", "image", "." ]

[ "def", "remove_out_of_image", "(", "self", ",", "fully", "=", "True", ",", "partly", "=", "False", ")", ":", "polys_clean", "=", "[", "poly", "for", "poly", "in", "self", ".", "polygons", "if", "not", "poly", ".", "is_out_of_image", "(", "self", ".", "shape", ",", "fully", "=", "fully", ",", "partly", "=", "partly", ")", "]", "# TODO use deepcopy() here", "return", "PolygonsOnImage", "(", "polys_clean", ",", "shape", "=", "self", ".", "shape", ")" ]

[ "Remove", "all", "polygons", "that", "are", "fully", "or", "partially", "outside", "of", "the", "image", "." ]

[ "def", "clip_out_of_image", "(", "self", ")", ":", "polys_cut", "=", "[", "poly", ".", "clip_out_of_image", "(", "self", ".", "shape", ")", "for", "poly", "in", "self", ".", "polygons", "if", "poly", ".", "is_partly_within_image", "(", "self", ".", "shape", ")", "]", "polys_cut_flat", "=", "[", "poly", "for", "poly_lst", "in", "polys_cut", "for", "poly", "in", "poly_lst", "]", "# TODO use deepcopy() here", "return", "PolygonsOnImage", "(", "polys_cut_flat", ",", "shape", "=", "self", ".", "shape", ")" ]

[ "Clip", "off", "all", "parts", "from", "all", "polygons", "that", "are", "outside", "of", "the", "image", "." ]

[ "def", "shift", "(", "self", ",", "top", "=", "None", ",", "right", "=", "None", ",", "bottom", "=", "None", ",", "left", "=", "None", ")", ":", "polys_new", "=", "[", "poly", ".", "shift", "(", "top", "=", "top", ",", "right", "=", "right", ",", "bottom", "=", "bottom", ",", "left", "=", "left", ")", "for", "poly", "in", "self", ".", "polygons", "]", "return", "PolygonsOnImage", "(", "polys_new", ",", "shape", "=", "self", ".", "shape", ")" ]

[ "Shift", "all", "polygons", "from", "one", "or", "more", "image", "sides", "i", ".", "e", ".", "move", "them", "on", "the", "x", "/", "y", "-", "axis", "." ]

[ "def", "deepcopy", "(", "self", ")", ":", "# Manual copy is far faster than deepcopy for PolygonsOnImage,", "# so use manual copy here too", "polys", "=", "[", "poly", ".", "deepcopy", "(", ")", "for", "poly", "in", "self", ".", "polygons", "]", "return", "PolygonsOnImage", "(", "polys", ",", "tuple", "(", "self", ".", "shape", ")", ")" ]

[ "Create", "a", "deep", "copy", "of", "the", "PolygonsOnImage", "object", "." ]

[ "def", "from_shapely", "(", "geometry", ",", "label", "=", "None", ")", ":", "# load shapely lazily, which makes the dependency more optional", "import", "shapely", ".", "geometry", "if", "isinstance", "(", "geometry", ",", "shapely", ".", "geometry", ".", "MultiPolygon", ")", ":", "return", "MultiPolygon", "(", "[", "Polygon", ".", "from_shapely", "(", "poly", ",", "label", "=", "label", ")", "for", "poly", "in", "geometry", ".", "geoms", "]", ")", "elif", "isinstance", "(", "geometry", ",", "shapely", ".", "geometry", ".", "Polygon", ")", ":", "return", "MultiPolygon", "(", "[", "Polygon", ".", "from_shapely", "(", "geometry", ",", "label", "=", "label", ")", "]", ")", "elif", "isinstance", "(", "geometry", ",", "shapely", ".", "geometry", ".", "collection", ".", "GeometryCollection", ")", ":", "ia", ".", "do_assert", "(", "all", "(", "[", "isinstance", "(", "poly", ",", "shapely", ".", "geometry", ".", "Polygon", ")", "for", "poly", "in", "geometry", ".", "geoms", "]", ")", ")", "return", "MultiPolygon", "(", "[", "Polygon", ".", "from_shapely", "(", "poly", ",", "label", "=", "label", ")", "for", "poly", "in", "geometry", ".", "geoms", "]", ")", "else", ":", "raise", "Exception", "(", "\"Unknown datatype '%s'. Expected shapely.geometry.Polygon or \"", "\"shapely.geometry.MultiPolygon or \"", "\"shapely.geometry.collections.GeometryCollection.\"", "%", "(", "type", "(", "geometry", ")", ",", ")", ")" ]

[ "Create", "a", "MultiPolygon", "from", "a", "Shapely", "MultiPolygon", "a", "Shapely", "Polygon", "or", "a", "Shapely", "GeometryCollection", "." ]

[ "def", "Pad", "(", "px", "=", "None", ",", "percent", "=", "None", ",", "pad_mode", "=", "\"constant\"", ",", "pad_cval", "=", "0", ",", "keep_size", "=", "True", ",", "sample_independently", "=", "True", ",", "name", "=", "None", ",", "deterministic", "=", "False", ",", "random_state", "=", "None", ")", ":", "def", "recursive_validate", "(", "v", ")", ":", "if", "v", "is", "None", ":", "return", "v", "elif", "ia", ".", "is_single_number", "(", "v", ")", ":", "ia", ".", "do_assert", "(", "v", ">=", "0", ")", "return", "v", "elif", "isinstance", "(", "v", ",", "iap", ".", "StochasticParameter", ")", ":", "return", "v", "elif", "isinstance", "(", "v", ",", "tuple", ")", ":", "return", "tuple", "(", "[", "recursive_validate", "(", "v_", ")", "for", "v_", "in", "v", "]", ")", "elif", "isinstance", "(", "v", ",", "list", ")", ":", "return", "[", "recursive_validate", "(", "v_", ")", "for", "v_", "in", "v", "]", "else", ":", "raise", "Exception", "(", "\"Expected None or int or float or StochasticParameter or list or tuple, got %s.\"", "%", "(", "type", "(", "v", ")", ",", ")", ")", "px", "=", "recursive_validate", "(", "px", ")", "percent", "=", "recursive_validate", "(", "percent", ")", "if", "name", "is", "None", ":", "name", "=", "\"Unnamed%s\"", "%", "(", "ia", ".", "caller_name", "(", ")", ",", ")", "aug", "=", "CropAndPad", "(", "px", "=", "px", ",", "percent", "=", "percent", ",", "pad_mode", "=", "pad_mode", ",", "pad_cval", "=", "pad_cval", ",", "keep_size", "=", "keep_size", ",", "sample_independently", "=", "sample_independently", ",", "name", "=", "name", ",", "deterministic", "=", "deterministic", ",", "random_state", "=", "random_state", ")", "return", "aug" ]

[ "Augmenter", "that", "pads", "images", "i", ".", "e", ".", "adds", "columns", "/", "rows", "to", "them", "." ]

[ "def", "Crop", "(", "px", "=", "None", ",", "percent", "=", "None", ",", "keep_size", "=", "True", ",", "sample_independently", "=", "True", ",", "name", "=", "None", ",", "deterministic", "=", "False", ",", "random_state", "=", "None", ")", ":", "def", "recursive_negate", "(", "v", ")", ":", "if", "v", "is", "None", ":", "return", "v", "elif", "ia", ".", "is_single_number", "(", "v", ")", ":", "ia", ".", "do_assert", "(", "v", ">=", "0", ")", "return", "-", "v", "elif", "isinstance", "(", "v", ",", "iap", ".", "StochasticParameter", ")", ":", "return", "iap", ".", "Multiply", "(", "v", ",", "-", "1", ")", "elif", "isinstance", "(", "v", ",", "tuple", ")", ":", "return", "tuple", "(", "[", "recursive_negate", "(", "v_", ")", "for", "v_", "in", "v", "]", ")", "elif", "isinstance", "(", "v", ",", "list", ")", ":", "return", "[", "recursive_negate", "(", "v_", ")", "for", "v_", "in", "v", "]", "else", ":", "raise", "Exception", "(", "\"Expected None or int or float or StochasticParameter or list or tuple, got %s.\"", "%", "(", "type", "(", "v", ")", ",", ")", ")", "px", "=", "recursive_negate", "(", "px", ")", "percent", "=", "recursive_negate", "(", "percent", ")", "if", "name", "is", "None", ":", "name", "=", "\"Unnamed%s\"", "%", "(", "ia", ".", "caller_name", "(", ")", ",", ")", "aug", "=", "CropAndPad", "(", "px", "=", "px", ",", "percent", "=", "percent", ",", "keep_size", "=", "keep_size", ",", "sample_independently", "=", "sample_independently", ",", "name", "=", "name", ",", "deterministic", "=", "deterministic", ",", "random_state", "=", "random_state", ")", "return", "aug" ]

[ "Augmenter", "that", "crops", "/", "cuts", "away", "pixels", "at", "the", "sides", "of", "the", "image", "." ]

[ "def", "isect_segments__naive", "(", "segments", ")", ":", "isect", "=", "[", "]", "# order points left -> right", "if", "Real", "is", "float", ":", "segments", "=", "[", "(", "s", "[", "0", "]", ",", "s", "[", "1", "]", ")", "if", "s", "[", "0", "]", "[", "X", "]", "<=", "s", "[", "1", "]", "[", "X", "]", "else", "(", "s", "[", "1", "]", ",", "s", "[", "0", "]", ")", "for", "s", "in", "segments", "]", "else", ":", "segments", "=", "[", "(", "(", "Real", "(", "s", "[", "0", "]", "[", "0", "]", ")", ",", "Real", "(", "s", "[", "0", "]", "[", "1", "]", ")", ")", ",", "(", "Real", "(", "s", "[", "1", "]", "[", "0", "]", ")", ",", "Real", "(", "s", "[", "1", "]", "[", "1", "]", ")", ")", ",", ")", "if", "(", "s", "[", "0", "]", "<=", "s", "[", "1", "]", ")", "else", "(", "(", "Real", "(", "s", "[", "1", "]", "[", "0", "]", ")", ",", "Real", "(", "s", "[", "1", "]", "[", "1", "]", ")", ")", ",", "(", "Real", "(", "s", "[", "0", "]", "[", "0", "]", ")", ",", "Real", "(", "s", "[", "0", "]", "[", "1", "]", ")", ")", ",", ")", "for", "s", "in", "segments", "]", "n", "=", "len", "(", "segments", ")", "for", "i", "in", "range", "(", "n", ")", ":", "a0", ",", "a1", "=", "segments", "[", "i", "]", "for", "j", "in", "range", "(", "i", "+", "1", ",", "n", ")", ":", "b0", ",", "b1", "=", "segments", "[", "j", "]", "if", "a0", "not", "in", "(", "b0", ",", "b1", ")", "and", "a1", "not", "in", "(", "b0", ",", "b1", ")", ":", "ix", "=", "isect_seg_seg_v2_point", "(", "a0", ",", "a1", ",", "b0", ",", "b1", ")", "if", "ix", "is", "not", "None", ":", "# USE_IGNORE_SEGMENT_ENDINGS handled already", "isect", ".", "append", "(", "ix", ")", "return", "isect" ]

[ "Brute", "force", "O", "(", "n2", ")", "version", "of", "isect_segments", "for", "test", "validation", "." ]

[ "def", "isect_polygon__naive", "(", "points", ")", ":", "isect", "=", "[", "]", "n", "=", "len", "(", "points", ")", "if", "Real", "is", "float", ":", "pass", "else", ":", "points", "=", "[", "(", "Real", "(", "p", "[", "0", "]", ")", ",", "Real", "(", "p", "[", "1", "]", ")", ")", "for", "p", "in", "points", "]", "for", "i", "in", "range", "(", "n", ")", ":", "a0", ",", "a1", "=", "points", "[", "i", "]", ",", "points", "[", "(", "i", "+", "1", ")", "%", "n", "]", "for", "j", "in", "range", "(", "i", "+", "1", ",", "n", ")", ":", "b0", ",", "b1", "=", "points", "[", "j", "]", ",", "points", "[", "(", "j", "+", "1", ")", "%", "n", "]", "if", "a0", "not", "in", "(", "b0", ",", "b1", ")", "and", "a1", "not", "in", "(", "b0", ",", "b1", ")", ":", "ix", "=", "isect_seg_seg_v2_point", "(", "a0", ",", "a1", ",", "b0", ",", "b1", ")", "if", "ix", "is", "not", "None", ":", "if", "USE_IGNORE_SEGMENT_ENDINGS", ":", "if", "(", "(", "len_squared_v2v2", "(", "ix", ",", "a0", ")", "<", "NUM_EPS_SQ", "or", "len_squared_v2v2", "(", "ix", ",", "a1", ")", "<", "NUM_EPS_SQ", ")", "and", "(", "len_squared_v2v2", "(", "ix", ",", "b0", ")", "<", "NUM_EPS_SQ", "or", "len_squared_v2v2", "(", "ix", ",", "b1", ")", "<", "NUM_EPS_SQ", ")", ")", ":", "continue", "isect", ".", "append", "(", "ix", ")", "return", "isect" ]

[ "Brute", "force", "O", "(", "n2", ")", "version", "of", "isect_polygon", "for", "test", "validation", "." ]

[ "def", "get_intersections", "(", "self", ")", ":", "if", "Real", "is", "float", ":", "return", "list", "(", "self", ".", "intersections", ".", "keys", "(", ")", ")", "else", ":", "return", "[", "(", "float", "(", "p", "[", "0", "]", ")", ",", "float", "(", "p", "[", "1", "]", ")", ")", "for", "p", "in", "self", ".", "intersections", ".", "keys", "(", ")", "]" ]

[ "Return", "a", "list", "of", "unordered", "intersection", "points", "." ]

[ "def", "get_intersections_with_segments", "(", "self", ")", ":", "if", "Real", "is", "float", ":", "return", "[", "(", "p", ",", "[", "event", ".", "segment", "for", "event", "in", "event_set", "]", ")", "for", "p", ",", "event_set", "in", "self", ".", "intersections", ".", "items", "(", ")", "]", "else", ":", "return", "[", "(", "(", "float", "(", "p", "[", "0", "]", ")", ",", "float", "(", "p", "[", "1", "]", ")", ")", ",", "[", "(", "(", "float", "(", "event", ".", "segment", "[", "0", "]", "[", "0", "]", ")", ",", "float", "(", "event", ".", "segment", "[", "0", "]", "[", "1", "]", ")", ")", ",", "(", "float", "(", "event", ".", "segment", "[", "1", "]", "[", "0", "]", ")", ",", "float", "(", "event", ".", "segment", "[", "1", "]", "[", "1", "]", ")", ")", ")", "for", "event", "in", "event_set", "]", ",", ")", "for", "p", ",", "event_set", "in", "self", ".", "intersections", ".", "items", "(", ")", "]" ]

[ "Return", "a", "list", "of", "unordered", "intersection", "(", "point", "segment", ")", "pairs", "where", "segments", "may", "contain", "2", "or", "more", "values", "." ]

[ "def", "poll", "(", "self", ")", ":", "assert", "(", "len", "(", "self", ".", "events_scan", ")", "!=", "0", ")", "p", ",", "events_current", "=", "self", ".", "events_scan", ".", "pop_min", "(", ")", "return", "p", ",", "events_current" ]

[ "Get", "and", "remove", "the", "first", "(", "lowest", ")", "item", "from", "this", "queue", "." ]

[ "def", "clear", "(", "self", ")", ":", "def", "_clear", "(", "node", ")", ":", "if", "node", "is", "not", "None", ":", "_clear", "(", "node", ".", "left", ")", "_clear", "(", "node", ".", "right", ")", "node", ".", "free", "(", ")", "_clear", "(", "self", ".", "_root", ")", "self", ".", "_count", "=", "0", "self", ".", "_root", "=", "None" ]

[ "T", ".", "clear", "()", "-", ">", "None", ".", "Remove", "all", "items", "from", "T", "." ]

[ "def", "pop_item", "(", "self", ")", ":", "if", "self", ".", "is_empty", "(", ")", ":", "raise", "KeyError", "(", "\"pop_item(): tree is empty\"", ")", "node", "=", "self", ".", "_root", "while", "True", ":", "if", "node", ".", "left", "is", "not", "None", ":", "node", "=", "node", ".", "left", "elif", "node", ".", "right", "is", "not", "None", ":", "node", "=", "node", ".", "right", "else", ":", "break", "key", "=", "node", ".", "key", "value", "=", "node", ".", "value", "self", ".", "remove", "(", "key", ")", "return", "key", ",", "value" ]

[ "T", ".", "pop_item", "()", "-", ">", "(", "k", "v", ")", "remove", "and", "return", "some", "(", "key", "value", ")", "pair", "as", "a", "2", "-", "tuple", ";", "but", "raise", "KeyError", "if", "T", "is", "empty", "." ]

[ "def", "min_item", "(", "self", ")", ":", "if", "self", ".", "is_empty", "(", ")", ":", "raise", "ValueError", "(", "\"Tree is empty\"", ")", "node", "=", "self", ".", "_root", "while", "node", ".", "left", "is", "not", "None", ":", "node", "=", "node", ".", "left", "return", "node", ".", "key", ",", "node", ".", "value" ]

[ "Get", "item", "with", "min", "key", "of", "tree", "raises", "ValueError", "if", "tree", "is", "empty", "." ]

[ "def", "max_item", "(", "self", ")", ":", "if", "self", ".", "is_empty", "(", ")", ":", "raise", "ValueError", "(", "\"Tree is empty\"", ")", "node", "=", "self", ".", "_root", "while", "node", ".", "right", "is", "not", "None", ":", "node", "=", "node", ".", "right", "return", "node", ".", "key", ",", "node", ".", "value" ]

[ "Get", "item", "with", "max", "key", "of", "tree", "raises", "ValueError", "if", "tree", "is", "empty", "." ]

[ "def", "succ_item", "(", "self", ",", "key", ",", "default", "=", "_sentinel", ")", ":", "# removed graingets version, because it was little slower on CPython and much slower on pypy", "# this version runs about 4x faster with pypy than the Cython version", "# Note: Code sharing of succ_item() and ceiling_item() is possible, but has always a speed penalty.", "node", "=", "self", ".", "_root", "succ_node", "=", "None", "while", "node", "is", "not", "None", ":", "cmp", "=", "self", ".", "_cmp", "(", "self", ".", "_cmp_data", ",", "key", ",", "node", ".", "key", ")", "if", "cmp", "==", "0", ":", "break", "elif", "cmp", "<", "0", ":", "if", "(", "succ_node", "is", "None", ")", "or", "self", ".", "_cmp", "(", "self", ".", "_cmp_data", ",", "node", ".", "key", ",", "succ_node", ".", "key", ")", "<", "0", ":", "succ_node", "=", "node", "node", "=", "node", ".", "left", "else", ":", "node", "=", "node", ".", "right", "if", "node", "is", "None", ":", "# stay at dead end", "if", "default", "is", "_sentinel", ":", "raise", "KeyError", "(", "str", "(", "key", ")", ")", "return", "default", "# found node of key", "if", "node", ".", "right", "is", "not", "None", ":", "# find smallest node of right subtree", "node", "=", "node", ".", "right", "while", "node", ".", "left", "is", "not", "None", ":", "node", "=", "node", ".", "left", "if", "succ_node", "is", "None", ":", "succ_node", "=", "node", "elif", "self", ".", "_cmp", "(", "self", ".", "_cmp_data", ",", "node", ".", "key", ",", "succ_node", ".", "key", ")", "<", "0", ":", "succ_node", "=", "node", "elif", "succ_node", "is", "None", ":", "# given key is biggest in tree", "if", "default", "is", "_sentinel", ":", "raise", "KeyError", "(", "str", "(", "key", ")", ")", "return", "default", "return", "succ_node", ".", "key", ",", "succ_node", ".", "value" ]

[ "Get", "successor", "(", "k", "v", ")", "pair", "of", "key", "raises", "KeyError", "if", "key", "is", "max", "key", "or", "key", "does", "not", "exist", ".", "optimized", "for", "pypy", "." ]

[ "def", "prev_item", "(", "self", ",", "key", ",", "default", "=", "_sentinel", ")", ":", "# removed graingets version, because it was little slower on CPython and much slower on pypy", "# this version runs about 4x faster with pypy than the Cython version", "# Note: Code sharing of prev_item() and floor_item() is possible, but has always a speed penalty.", "node", "=", "self", ".", "_root", "prev_node", "=", "None", "while", "node", "is", "not", "None", ":", "cmp", "=", "self", ".", "_cmp", "(", "self", ".", "_cmp_data", ",", "key", ",", "node", ".", "key", ")", "if", "cmp", "==", "0", ":", "break", "elif", "cmp", "<", "0", ":", "node", "=", "node", ".", "left", "else", ":", "if", "(", "prev_node", "is", "None", ")", "or", "self", ".", "_cmp", "(", "self", ".", "_cmp_data", ",", "prev_node", ".", "key", ",", "node", ".", "key", ")", "<", "0", ":", "prev_node", "=", "node", "node", "=", "node", ".", "right", "if", "node", "is", "None", ":", "# stay at dead end (None)", "if", "default", "is", "_sentinel", ":", "raise", "KeyError", "(", "str", "(", "key", ")", ")", "return", "default", "# found node of key", "if", "node", ".", "left", "is", "not", "None", ":", "# find biggest node of left subtree", "node", "=", "node", ".", "left", "while", "node", ".", "right", "is", "not", "None", ":", "node", "=", "node", ".", "right", "if", "prev_node", "is", "None", ":", "prev_node", "=", "node", "elif", "self", ".", "_cmp", "(", "self", ".", "_cmp_data", ",", "prev_node", ".", "key", ",", "node", ".", "key", ")", "<", "0", ":", "prev_node", "=", "node", "elif", "prev_node", "is", "None", ":", "# given key is smallest in tree", "if", "default", "is", "_sentinel", ":", "raise", "KeyError", "(", "str", "(", "key", ")", ")", "return", "default", "return", "prev_node", ".", "key", ",", "prev_node", ".", "value" ]

[ "Get", "predecessor", "(", "k", "v", ")", "pair", "of", "key", "raises", "KeyError", "if", "key", "is", "min", "key", "or", "key", "does", "not", "exist", ".", "optimized", "for", "pypy", "." ]

[ "def", "set_default", "(", "self", ",", "key", ",", "default", "=", "None", ")", ":", "try", ":", "return", "self", ".", "get_value", "(", "key", ")", "except", "KeyError", ":", "self", ".", "insert", "(", "key", ",", "default", ")", "return", "default" ]

[ "T", ".", "set_default", "(", "k", "[", "d", "]", ")", "-", ">", "T", ".", "get", "(", "k", "d", ")", "also", "set", "T", "[", "k", "]", "=", "d", "if", "k", "not", "in", "T" ]

[ "def", "pop", "(", "self", ",", "key", ",", "*", "args", ")", ":", "if", "len", "(", "args", ")", ">", "1", ":", "raise", "TypeError", "(", "\"pop expected at most 2 arguments, got %d\"", "%", "(", "1", "+", "len", "(", "args", ")", ")", ")", "try", ":", "value", "=", "self", ".", "get_value", "(", "key", ")", "self", ".", "remove", "(", "key", ")", "return", "value", "except", "KeyError", ":", "if", "len", "(", "args", ")", "==", "0", ":", "raise", "else", ":", "return", "args", "[", "0", "]" ]

[ "T", ".", "pop", "(", "k", "[", "d", "]", ")", "-", ">", "v", "remove", "specified", "key", "and", "return", "the", "corresponding", "value", ".", "If", "key", "is", "not", "found", "d", "is", "returned", "if", "given", "otherwise", "KeyError", "is", "raised" ]

[ "def", "prev_key", "(", "self", ",", "key", ",", "default", "=", "_sentinel", ")", ":", "item", "=", "self", ".", "prev_item", "(", "key", ",", "default", ")", "return", "default", "if", "item", "is", "default", "else", "item", "[", "0", "]" ]

[ "Get", "predecessor", "to", "key", "raises", "KeyError", "if", "key", "is", "min", "key", "or", "key", "does", "not", "exist", "." ]

[ "def", "succ_key", "(", "self", ",", "key", ",", "default", "=", "_sentinel", ")", ":", "item", "=", "self", ".", "succ_item", "(", "key", ",", "default", ")", "return", "default", "if", "item", "is", "default", "else", "item", "[", "0", "]" ]

[ "Get", "successor", "to", "key", "raises", "KeyError", "if", "key", "is", "max", "key", "or", "key", "does", "not", "exist", "." ]

[ "def", "key_slice", "(", "self", ",", "start_key", ",", "end_key", ",", "reverse", "=", "False", ")", ":", "return", "(", "k", "for", "k", ",", "v", "in", "self", ".", "iter_items", "(", "start_key", ",", "end_key", ",", "reverse", "=", "reverse", ")", ")" ]

[ "T", ".", "key_slice", "(", "start_key", "end_key", ")", "-", ">", "key", "iterator", ":", "start_key", "<", "=", "key", "<", "end_key", "." ]

[ "def", "iter_items", "(", "self", ",", "start_key", "=", "None", ",", "end_key", "=", "None", ",", "reverse", "=", "False", ")", ":", "# optimized iterator (reduced method calls) - faster on CPython but slower on pypy", "if", "self", ".", "is_empty", "(", ")", ":", "return", "[", "]", "if", "reverse", ":", "return", "self", ".", "_iter_items_backward", "(", "start_key", ",", "end_key", ")", "else", ":", "return", "self", ".", "_iter_items_forward", "(", "start_key", ",", "end_key", ")" ]

[ "Iterates", "over", "the", "(", "key", "value", ")", "items", "of", "the", "associated", "tree", "in", "ascending", "order", "if", "reverse", "is", "True", "iterate", "in", "descending", "order", "reverse", "defaults", "to", "False" ]

[ "def", "insert", "(", "self", ",", "key", ",", "value", ")", ":", "if", "self", ".", "_root", "is", "None", ":", "# Empty tree case", "self", ".", "_root", "=", "self", ".", "_new_node", "(", "key", ",", "value", ")", "self", ".", "_root", ".", "red", "=", "False", "# make root black", "return", "head", "=", "Node", "(", ")", "# False tree root", "grand_parent", "=", "None", "grand_grand_parent", "=", "head", "parent", "=", "None", "# parent", "direction", "=", "0", "last", "=", "0", "# Set up helpers", "grand_grand_parent", ".", "right", "=", "self", ".", "_root", "node", "=", "grand_grand_parent", ".", "right", "# Search down the tree", "while", "True", ":", "if", "node", "is", "None", ":", "# Insert new node at the bottom", "node", "=", "self", ".", "_new_node", "(", "key", ",", "value", ")", "parent", "[", "direction", "]", "=", "node", "elif", "RBTree", ".", "is_red", "(", "node", ".", "left", ")", "and", "RBTree", ".", "is_red", "(", "node", ".", "right", ")", ":", "# Color flip", "node", ".", "red", "=", "True", "node", ".", "left", ".", "red", "=", "False", "node", ".", "right", ".", "red", "=", "False", "# Fix red violation", "if", "RBTree", ".", "is_red", "(", "node", ")", "and", "RBTree", ".", "is_red", "(", "parent", ")", ":", "direction2", "=", "1", "if", "grand_grand_parent", ".", "right", "is", "grand_parent", "else", "0", "if", "node", "is", "parent", "[", "last", "]", ":", "grand_grand_parent", "[", "direction2", "]", "=", "RBTree", ".", "jsw_single", "(", "grand_parent", ",", "1", "-", "last", ")", "else", ":", "grand_grand_parent", "[", "direction2", "]", "=", "RBTree", ".", "jsw_double", "(", "grand_parent", ",", "1", "-", "last", ")", "# Stop if found", "if", "self", ".", "_cmp", "(", "self", ".", "_cmp_data", ",", "key", ",", "node", ".", "key", ")", "==", "0", ":", "node", ".", "value", "=", "value", "# set new value for key", "break", "last", "=", "direction", "direction", "=", "0", "if", "(", "self", ".", "_cmp", "(", "self", ".", "_cmp_data", ",", "key", ",", "node", ".", "key", ")", "<", "0", ")", "else", "1", "# Update helpers", "if", "grand_parent", "is", "not", "None", ":", "grand_grand_parent", "=", "grand_parent", "grand_parent", "=", "parent", "parent", "=", "node", "node", "=", "node", "[", "direction", "]", "self", ".", "_root", "=", "head", ".", "right", "# Update root", "self", ".", "_root", ".", "red", "=", "False" ]

[ "T", ".", "insert", "(", "key", "value", ")", "<", "==", ">", "T", "[", "key", "]", "=", "value", "insert", "key", "value", "into", "tree", "." ]

[ "def", "remove", "(", "self", ",", "key", ")", ":", "if", "self", ".", "_root", "is", "None", ":", "raise", "KeyError", "(", "str", "(", "key", ")", ")", "head", "=", "Node", "(", ")", "# False tree root", "node", "=", "head", "node", ".", "right", "=", "self", ".", "_root", "parent", "=", "None", "grand_parent", "=", "None", "found", "=", "None", "# Found item", "direction", "=", "1", "# Search and push a red down", "while", "node", "[", "direction", "]", "is", "not", "None", ":", "last", "=", "direction", "# Update helpers", "grand_parent", "=", "parent", "parent", "=", "node", "node", "=", "node", "[", "direction", "]", "direction", "=", "1", "if", "(", "self", ".", "_cmp", "(", "self", ".", "_cmp_data", ",", "node", ".", "key", ",", "key", ")", "<", "0", ")", "else", "0", "# Save found node", "if", "self", ".", "_cmp", "(", "self", ".", "_cmp_data", ",", "key", ",", "node", ".", "key", ")", "==", "0", ":", "found", "=", "node", "# Push the red node down", "if", "not", "RBTree", ".", "is_red", "(", "node", ")", "and", "not", "RBTree", ".", "is_red", "(", "node", "[", "direction", "]", ")", ":", "if", "RBTree", ".", "is_red", "(", "node", "[", "1", "-", "direction", "]", ")", ":", "parent", "[", "last", "]", "=", "RBTree", ".", "jsw_single", "(", "node", ",", "direction", ")", "parent", "=", "parent", "[", "last", "]", "elif", "not", "RBTree", ".", "is_red", "(", "node", "[", "1", "-", "direction", "]", ")", ":", "sibling", "=", "parent", "[", "1", "-", "last", "]", "if", "sibling", "is", "not", "None", ":", "if", "(", "not", "RBTree", ".", "is_red", "(", "sibling", "[", "1", "-", "last", "]", ")", ")", "and", "(", "not", "RBTree", ".", "is_red", "(", "sibling", "[", "last", "]", ")", ")", ":", "# Color flip", "parent", ".", "red", "=", "False", "sibling", ".", "red", "=", "True", "node", ".", "red", "=", "True", "else", ":", "direction2", "=", "1", "if", "grand_parent", ".", "right", "is", "parent", "else", "0", "if", "RBTree", ".", "is_red", "(", "sibling", "[", "last", "]", ")", ":", "grand_parent", "[", "direction2", "]", "=", "RBTree", ".", "jsw_double", "(", "parent", ",", "last", ")", "elif", "RBTree", ".", "is_red", "(", "sibling", "[", "1", "-", "last", "]", ")", ":", "grand_parent", "[", "direction2", "]", "=", "RBTree", ".", "jsw_single", "(", "parent", ",", "last", ")", "# Ensure correct coloring", "grand_parent", "[", "direction2", "]", ".", "red", "=", "True", "node", ".", "red", "=", "True", "grand_parent", "[", "direction2", "]", ".", "left", ".", "red", "=", "False", "grand_parent", "[", "direction2", "]", ".", "right", ".", "red", "=", "False", "# Replace and remove if found", "if", "found", "is", "not", "None", ":", "found", ".", "key", "=", "node", ".", "key", "found", ".", "value", "=", "node", ".", "value", "parent", "[", "int", "(", "parent", ".", "right", "is", "node", ")", "]", "=", "node", "[", "int", "(", "node", ".", "left", "is", "None", ")", "]", "node", ".", "free", "(", ")", "self", ".", "_count", "-=", "1", "# Update root and make it black", "self", ".", "_root", "=", "head", ".", "right", "if", "self", ".", "_root", "is", "not", "None", ":", "self", ".", "_root", ".", "red", "=", "False", "if", "not", "found", ":", "raise", "KeyError", "(", "str", "(", "key", ")", ")" ]

[ "T", ".", "remove", "(", "key", ")", "<", "==", ">", "del", "T", "[", "key", "]", "remove", "item", "<key", ">", "from", "tree", "." ]

[ "def", "noise2d", "(", "self", ",", "x", ",", "y", ")", ":", "# Place input coordinates onto grid.", "stretch_offset", "=", "(", "x", "+", "y", ")", "*", "STRETCH_CONSTANT_2D", "xs", "=", "x", "+", "stretch_offset", "ys", "=", "y", "+", "stretch_offset", "# Floor to get grid coordinates of rhombus (stretched square) super-cell origin.", "xsb", "=", "floor", "(", "xs", ")", "ysb", "=", "floor", "(", "ys", ")", "# Skew out to get actual coordinates of rhombus origin. We'll need these later.", "squish_offset", "=", "(", "xsb", "+", "ysb", ")", "*", "SQUISH_CONSTANT_2D", "xb", "=", "xsb", "+", "squish_offset", "yb", "=", "ysb", "+", "squish_offset", "# Compute grid coordinates relative to rhombus origin.", "xins", "=", "xs", "-", "xsb", "yins", "=", "ys", "-", "ysb", "# Sum those together to get a value that determines which region we're in.", "in_sum", "=", "xins", "+", "yins", "# Positions relative to origin point.", "dx0", "=", "x", "-", "xb", "dy0", "=", "y", "-", "yb", "value", "=", "0", "# Contribution (1,0)", "dx1", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_2D", "dy1", "=", "dy0", "-", "0", "-", "SQUISH_CONSTANT_2D", "attn1", "=", "2", "-", "dx1", "*", "dx1", "-", "dy1", "*", "dy1", "extrapolate", "=", "self", ".", "_extrapolate2d", "if", "attn1", ">", "0", ":", "attn1", "*=", "attn1", "value", "+=", "attn1", "*", "attn1", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "dx1", ",", "dy1", ")", "# Contribution (0,1)", "dx2", "=", "dx0", "-", "0", "-", "SQUISH_CONSTANT_2D", "dy2", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_2D", "attn2", "=", "2", "-", "dx2", "*", "dx2", "-", "dy2", "*", "dy2", "if", "attn2", ">", "0", ":", "attn2", "*=", "attn2", "value", "+=", "attn2", "*", "attn2", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "dx2", ",", "dy2", ")", "if", "in_sum", "<=", "1", ":", "# We're inside the triangle (2-Simplex) at (0,0)", "zins", "=", "1", "-", "in_sum", "if", "zins", ">", "xins", "or", "zins", ">", "yins", ":", "# (0,0) is one of the closest two triangular vertices", "if", "xins", ">", "yins", ":", "xsv_ext", "=", "xsb", "+", "1", "ysv_ext", "=", "ysb", "-", "1", "dx_ext", "=", "dx0", "-", "1", "dy_ext", "=", "dy0", "+", "1", "else", ":", "xsv_ext", "=", "xsb", "-", "1", "ysv_ext", "=", "ysb", "+", "1", "dx_ext", "=", "dx0", "+", "1", "dy_ext", "=", "dy0", "-", "1", "else", ":", "# (1,0) and (0,1) are the closest two vertices.", "xsv_ext", "=", "xsb", "+", "1", "ysv_ext", "=", "ysb", "+", "1", "dx_ext", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_2D", "dy_ext", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_2D", "else", ":", "# We're inside the triangle (2-Simplex) at (1,1)", "zins", "=", "2", "-", "in_sum", "if", "zins", "<", "xins", "or", "zins", "<", "yins", ":", "# (0,0) is one of the closest two triangular vertices", "if", "xins", ">", "yins", ":", "xsv_ext", "=", "xsb", "+", "2", "ysv_ext", "=", "ysb", "+", "0", "dx_ext", "=", "dx0", "-", "2", "-", "2", "*", "SQUISH_CONSTANT_2D", "dy_ext", "=", "dy0", "+", "0", "-", "2", "*", "SQUISH_CONSTANT_2D", "else", ":", "xsv_ext", "=", "xsb", "+", "0", "ysv_ext", "=", "ysb", "+", "2", "dx_ext", "=", "dx0", "+", "0", "-", "2", "*", "SQUISH_CONSTANT_2D", "dy_ext", "=", "dy0", "-", "2", "-", "2", "*", "SQUISH_CONSTANT_2D", "else", ":", "# (1,0) and (0,1) are the closest two vertices.", "dx_ext", "=", "dx0", "dy_ext", "=", "dy0", "xsv_ext", "=", "xsb", "ysv_ext", "=", "ysb", "xsb", "+=", "1", "ysb", "+=", "1", "dx0", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_2D", "dy0", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_2D", "# Contribution (0,0) or (1,1)", "attn0", "=", "2", "-", "dx0", "*", "dx0", "-", "dy0", "*", "dy0", "if", "attn0", ">", "0", ":", "attn0", "*=", "attn0", "value", "+=", "attn0", "*", "attn0", "*", "extrapolate", "(", "xsb", ",", "ysb", ",", "dx0", ",", "dy0", ")", "# Extra Vertex", "attn_ext", "=", "2", "-", "dx_ext", "*", "dx_ext", "-", "dy_ext", "*", "dy_ext", "if", "attn_ext", ">", "0", ":", "attn_ext", "*=", "attn_ext", "value", "+=", "attn_ext", "*", "attn_ext", "*", "extrapolate", "(", "xsv_ext", ",", "ysv_ext", ",", "dx_ext", ",", "dy_ext", ")", "return", "value", "/", "NORM_CONSTANT_2D" ]

[ "Generate", "2D", "OpenSimplex", "noise", "from", "X", "Y", "coordinates", "." ]

[ "def", "noise3d", "(", "self", ",", "x", ",", "y", ",", "z", ")", ":", "# Place input coordinates on simplectic honeycomb.", "stretch_offset", "=", "(", "x", "+", "y", "+", "z", ")", "*", "STRETCH_CONSTANT_3D", "xs", "=", "x", "+", "stretch_offset", "ys", "=", "y", "+", "stretch_offset", "zs", "=", "z", "+", "stretch_offset", "# Floor to get simplectic honeycomb coordinates of rhombohedron (stretched cube) super-cell origin.", "xsb", "=", "floor", "(", "xs", ")", "ysb", "=", "floor", "(", "ys", ")", "zsb", "=", "floor", "(", "zs", ")", "# Skew out to get actual coordinates of rhombohedron origin. We'll need these later.", "squish_offset", "=", "(", "xsb", "+", "ysb", "+", "zsb", ")", "*", "SQUISH_CONSTANT_3D", "xb", "=", "xsb", "+", "squish_offset", "yb", "=", "ysb", "+", "squish_offset", "zb", "=", "zsb", "+", "squish_offset", "# Compute simplectic honeycomb coordinates relative to rhombohedral origin.", "xins", "=", "xs", "-", "xsb", "yins", "=", "ys", "-", "ysb", "zins", "=", "zs", "-", "zsb", "# Sum those together to get a value that determines which region we're in.", "in_sum", "=", "xins", "+", "yins", "+", "zins", "# Positions relative to origin point.", "dx0", "=", "x", "-", "xb", "dy0", "=", "y", "-", "yb", "dz0", "=", "z", "-", "zb", "value", "=", "0", "extrapolate", "=", "self", ".", "_extrapolate3d", "if", "in_sum", "<=", "1", ":", "# We're inside the tetrahedron (3-Simplex) at (0,0,0)", "# Determine which two of (0,0,1), (0,1,0), (1,0,0) are closest.", "a_point", "=", "0x01", "a_score", "=", "xins", "b_point", "=", "0x02", "b_score", "=", "yins", "if", "a_score", ">=", "b_score", "and", "zins", ">", "b_score", ":", "b_score", "=", "zins", "b_point", "=", "0x04", "elif", "a_score", "<", "b_score", "and", "zins", ">", "a_score", ":", "a_score", "=", "zins", "a_point", "=", "0x04", "# Now we determine the two lattice points not part of the tetrahedron that may contribute.", "# This depends on the closest two tetrahedral vertices, including (0,0,0)", "wins", "=", "1", "-", "in_sum", "if", "wins", ">", "a_score", "or", "wins", ">", "b_score", ":", "# (0,0,0) is one of the closest two tetrahedral vertices.", "c", "=", "b_point", "if", "(", "b_score", ">", "a_score", ")", "else", "a_point", "# Our other closest vertex is the closest out of a and b.", "if", "(", "c", "&", "0x01", ")", "==", "0", ":", "xsv_ext0", "=", "xsb", "-", "1", "xsv_ext1", "=", "xsb", "dx_ext0", "=", "dx0", "+", "1", "dx_ext1", "=", "dx0", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsb", "+", "1", "dx_ext0", "=", "dx_ext1", "=", "dx0", "-", "1", "if", "(", "c", "&", "0x02", ")", "==", "0", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "dy_ext0", "=", "dy_ext1", "=", "dy0", "if", "(", "c", "&", "0x01", ")", "==", "0", ":", "ysv_ext1", "-=", "1", "dy_ext1", "+=", "1", "else", ":", "ysv_ext0", "-=", "1", "dy_ext0", "+=", "1", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "+", "1", "dy_ext0", "=", "dy_ext1", "=", "dy0", "-", "1", "if", "(", "c", "&", "0x04", ")", "==", "0", ":", "zsv_ext0", "=", "zsb", "zsv_ext1", "=", "zsb", "-", "1", "dz_ext0", "=", "dz0", "dz_ext1", "=", "dz0", "+", "1", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "+", "1", "dz_ext0", "=", "dz_ext1", "=", "dz0", "-", "1", "else", ":", "# (0,0,0) is not one of the closest two tetrahedral vertices.", "c", "=", "(", "a_point", "|", "b_point", ")", "# Our two extra vertices are determined by the closest two.", "if", "(", "c", "&", "0x01", ")", "==", "0", ":", "xsv_ext0", "=", "xsb", "xsv_ext1", "=", "xsb", "-", "1", "dx_ext0", "=", "dx0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dx_ext1", "=", "dx0", "+", "1", "-", "SQUISH_CONSTANT_3D", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsb", "+", "1", "dx_ext0", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_3D", "dx_ext1", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_3D", "if", "(", "c", "&", "0x02", ")", "==", "0", ":", "ysv_ext0", "=", "ysb", "ysv_ext1", "=", "ysb", "-", "1", "dy_ext0", "=", "dy0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dy_ext1", "=", "dy0", "+", "1", "-", "SQUISH_CONSTANT_3D", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "+", "1", "dy_ext0", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_3D", "dy_ext1", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_3D", "if", "(", "c", "&", "0x04", ")", "==", "0", ":", "zsv_ext0", "=", "zsb", "zsv_ext1", "=", "zsb", "-", "1", "dz_ext0", "=", "dz0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dz_ext1", "=", "dz0", "+", "1", "-", "SQUISH_CONSTANT_3D", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "+", "1", "dz_ext0", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_3D", "dz_ext1", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_3D", "# Contribution (0,0,0)", "attn0", "=", "2", "-", "dx0", "*", "dx0", "-", "dy0", "*", "dy0", "-", "dz0", "*", "dz0", "if", "attn0", ">", "0", ":", "attn0", "*=", "attn0", "value", "+=", "attn0", "*", "attn0", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "0", ",", "zsb", "+", "0", ",", "dx0", ",", "dy0", ",", "dz0", ")", "# Contribution (1,0,0)", "dx1", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dy1", "=", "dy0", "-", "0", "-", "SQUISH_CONSTANT_3D", "dz1", "=", "dz0", "-", "0", "-", "SQUISH_CONSTANT_3D", "attn1", "=", "2", "-", "dx1", "*", "dx1", "-", "dy1", "*", "dy1", "-", "dz1", "*", "dz1", "if", "attn1", ">", "0", ":", "attn1", "*=", "attn1", "value", "+=", "attn1", "*", "attn1", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "zsb", "+", "0", ",", "dx1", ",", "dy1", ",", "dz1", ")", "# Contribution (0,1,0)", "dx2", "=", "dx0", "-", "0", "-", "SQUISH_CONSTANT_3D", "dy2", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dz2", "=", "dz1", "attn2", "=", "2", "-", "dx2", "*", "dx2", "-", "dy2", "*", "dy2", "-", "dz2", "*", "dz2", "if", "attn2", ">", "0", ":", "attn2", "*=", "attn2", "value", "+=", "attn2", "*", "attn2", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "zsb", "+", "0", ",", "dx2", ",", "dy2", ",", "dz2", ")", "# Contribution (0,0,1)", "dx3", "=", "dx2", "dy3", "=", "dy1", "dz3", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_3D", "attn3", "=", "2", "-", "dx3", "*", "dx3", "-", "dy3", "*", "dy3", "-", "dz3", "*", "dz3", "if", "attn3", ">", "0", ":", "attn3", "*=", "attn3", "value", "+=", "attn3", "*", "attn3", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "0", ",", "zsb", "+", "1", ",", "dx3", ",", "dy3", ",", "dz3", ")", "elif", "in_sum", ">=", "2", ":", "# We're inside the tetrahedron (3-Simplex) at (1,1,1)", "# Determine which two tetrahedral vertices are the closest, out of (1,1,0), (1,0,1), (0,1,1) but not (1,1,1).", "a_point", "=", "0x06", "a_score", "=", "xins", "b_point", "=", "0x05", "b_score", "=", "yins", "if", "a_score", "<=", "b_score", "and", "zins", "<", "b_score", ":", "b_score", "=", "zins", "b_point", "=", "0x03", "elif", "a_score", ">", "b_score", "and", "zins", "<", "a_score", ":", "a_score", "=", "zins", "a_point", "=", "0x03", "# Now we determine the two lattice points not part of the tetrahedron that may contribute.", "# This depends on the closest two tetrahedral vertices, including (1,1,1)", "wins", "=", "3", "-", "in_sum", "if", "wins", "<", "a_score", "or", "wins", "<", "b_score", ":", "# (1,1,1) is one of the closest two tetrahedral vertices.", "c", "=", "b_point", "if", "(", "b_score", "<", "a_score", ")", "else", "a_point", "# Our other closest vertex is the closest out of a and b.", "if", "(", "c", "&", "0x01", ")", "!=", "0", ":", "xsv_ext0", "=", "xsb", "+", "2", "xsv_ext1", "=", "xsb", "+", "1", "dx_ext0", "=", "dx0", "-", "2", "-", "3", "*", "SQUISH_CONSTANT_3D", "dx_ext1", "=", "dx0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_3D", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsb", "dx_ext0", "=", "dx_ext1", "=", "dx0", "-", "3", "*", "SQUISH_CONSTANT_3D", "if", "(", "c", "&", "0x02", ")", "!=", "0", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "+", "1", "dy_ext0", "=", "dy_ext1", "=", "dy0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_3D", "if", "(", "c", "&", "0x01", ")", "!=", "0", ":", "ysv_ext1", "+=", "1", "dy_ext1", "-=", "1", "else", ":", "ysv_ext0", "+=", "1", "dy_ext0", "-=", "1", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "dy_ext0", "=", "dy_ext1", "=", "dy0", "-", "3", "*", "SQUISH_CONSTANT_3D", "if", "(", "c", "&", "0x04", ")", "!=", "0", ":", "zsv_ext0", "=", "zsb", "+", "1", "zsv_ext1", "=", "zsb", "+", "2", "dz_ext0", "=", "dz0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_3D", "dz_ext1", "=", "dz0", "-", "2", "-", "3", "*", "SQUISH_CONSTANT_3D", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "dz_ext0", "=", "dz_ext1", "=", "dz0", "-", "3", "*", "SQUISH_CONSTANT_3D", "else", ":", "# (1,1,1) is not one of the closest two tetrahedral vertices.", "c", "=", "(", "a_point", "&", "b_point", ")", "# Our two extra vertices are determined by the closest two.", "if", "(", "c", "&", "0x01", ")", "!=", "0", ":", "xsv_ext0", "=", "xsb", "+", "1", "xsv_ext1", "=", "xsb", "+", "2", "dx_ext0", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dx_ext1", "=", "dx0", "-", "2", "-", "2", "*", "SQUISH_CONSTANT_3D", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsb", "dx_ext0", "=", "dx0", "-", "SQUISH_CONSTANT_3D", "dx_ext1", "=", "dx0", "-", "2", "*", "SQUISH_CONSTANT_3D", "if", "(", "c", "&", "0x02", ")", "!=", "0", ":", "ysv_ext0", "=", "ysb", "+", "1", "ysv_ext1", "=", "ysb", "+", "2", "dy_ext0", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dy_ext1", "=", "dy0", "-", "2", "-", "2", "*", "SQUISH_CONSTANT_3D", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "dy_ext0", "=", "dy0", "-", "SQUISH_CONSTANT_3D", "dy_ext1", "=", "dy0", "-", "2", "*", "SQUISH_CONSTANT_3D", "if", "(", "c", "&", "0x04", ")", "!=", "0", ":", "zsv_ext0", "=", "zsb", "+", "1", "zsv_ext1", "=", "zsb", "+", "2", "dz_ext0", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dz_ext1", "=", "dz0", "-", "2", "-", "2", "*", "SQUISH_CONSTANT_3D", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "dz_ext0", "=", "dz0", "-", "SQUISH_CONSTANT_3D", "dz_ext1", "=", "dz0", "-", "2", "*", "SQUISH_CONSTANT_3D", "# Contribution (1,1,0)", "dx3", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_3D", "dy3", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_3D", "dz3", "=", "dz0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_3D", "attn3", "=", "2", "-", "dx3", "*", "dx3", "-", "dy3", "*", "dy3", "-", "dz3", "*", "dz3", "if", "attn3", ">", "0", ":", "attn3", "*=", "attn3", "value", "+=", "attn3", "*", "attn3", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "1", ",", "zsb", "+", "0", ",", "dx3", ",", "dy3", ",", "dz3", ")", "# Contribution (1,0,1)", "dx2", "=", "dx3", "dy2", "=", "dy0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dz2", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_3D", "attn2", "=", "2", "-", "dx2", "*", "dx2", "-", "dy2", "*", "dy2", "-", "dz2", "*", "dz2", "if", "attn2", ">", "0", ":", "attn2", "*=", "attn2", "value", "+=", "attn2", "*", "attn2", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "zsb", "+", "1", ",", "dx2", ",", "dy2", ",", "dz2", ")", "# Contribution (0,1,1)", "dx1", "=", "dx0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dy1", "=", "dy3", "dz1", "=", "dz2", "attn1", "=", "2", "-", "dx1", "*", "dx1", "-", "dy1", "*", "dy1", "-", "dz1", "*", "dz1", "if", "attn1", ">", "0", ":", "attn1", "*=", "attn1", "value", "+=", "attn1", "*", "attn1", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "zsb", "+", "1", ",", "dx1", ",", "dy1", ",", "dz1", ")", "# Contribution (1,1,1)", "dx0", "=", "dx0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_3D", "dy0", "=", "dy0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_3D", "dz0", "=", "dz0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_3D", "attn0", "=", "2", "-", "dx0", "*", "dx0", "-", "dy0", "*", "dy0", "-", "dz0", "*", "dz0", "if", "attn0", ">", "0", ":", "attn0", "*=", "attn0", "value", "+=", "attn0", "*", "attn0", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "1", ",", "zsb", "+", "1", ",", "dx0", ",", "dy0", ",", "dz0", ")", "else", ":", "# We're inside the octahedron (Rectified 3-Simplex) in between.", "# Decide between point (0,0,1) and (1,1,0) as closest", "p1", "=", "xins", "+", "yins", "if", "p1", ">", "1", ":", "a_score", "=", "p1", "-", "1", "a_point", "=", "0x03", "a_is_further_side", "=", "True", "else", ":", "a_score", "=", "1", "-", "p1", "a_point", "=", "0x04", "a_is_further_side", "=", "False", "# Decide between point (0,1,0) and (1,0,1) as closest", "p2", "=", "xins", "+", "zins", "if", "p2", ">", "1", ":", "b_score", "=", "p2", "-", "1", "b_point", "=", "0x05", "b_is_further_side", "=", "True", "else", ":", "b_score", "=", "1", "-", "p2", "b_point", "=", "0x02", "b_is_further_side", "=", "False", "# The closest out of the two (1,0,0) and (0,1,1) will replace the furthest out of the two decided above, if closer.", "p3", "=", "yins", "+", "zins", "if", "p3", ">", "1", ":", "score", "=", "p3", "-", "1", "if", "a_score", "<=", "b_score", "and", "a_score", "<", "score", ":", "a_point", "=", "0x06", "a_is_further_side", "=", "True", "elif", "a_score", ">", "b_score", "and", "b_score", "<", "score", ":", "b_point", "=", "0x06", "b_is_further_side", "=", "True", "else", ":", "score", "=", "1", "-", "p3", "if", "a_score", "<=", "b_score", "and", "a_score", "<", "score", ":", "a_point", "=", "0x01", "a_is_further_side", "=", "False", "elif", "a_score", ">", "b_score", "and", "b_score", "<", "score", ":", "b_point", "=", "0x01", "b_is_further_side", "=", "False", "# Where each of the two closest points are determines how the extra two vertices are calculated.", "if", "a_is_further_side", "==", "b_is_further_side", ":", "if", "a_is_further_side", ":", "# Both closest points on (1,1,1) side", "# One of the two extra points is (1,1,1)", "dx_ext0", "=", "dx0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_3D", "dy_ext0", "=", "dy0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_3D", "dz_ext0", "=", "dz0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_3D", "xsv_ext0", "=", "xsb", "+", "1", "ysv_ext0", "=", "ysb", "+", "1", "zsv_ext0", "=", "zsb", "+", "1", "# Other extra point is based on the shared axis.", "c", "=", "(", "a_point", "&", "b_point", ")", "if", "(", "c", "&", "0x01", ")", "!=", "0", ":", "dx_ext1", "=", "dx0", "-", "2", "-", "2", "*", "SQUISH_CONSTANT_3D", "dy_ext1", "=", "dy0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dz_ext1", "=", "dz0", "-", "2", "*", "SQUISH_CONSTANT_3D", "xsv_ext1", "=", "xsb", "+", "2", "ysv_ext1", "=", "ysb", "zsv_ext1", "=", "zsb", "elif", "(", "c", "&", "0x02", ")", "!=", "0", ":", "dx_ext1", "=", "dx0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dy_ext1", "=", "dy0", "-", "2", "-", "2", "*", "SQUISH_CONSTANT_3D", "dz_ext1", "=", "dz0", "-", "2", "*", "SQUISH_CONSTANT_3D", "xsv_ext1", "=", "xsb", "ysv_ext1", "=", "ysb", "+", "2", "zsv_ext1", "=", "zsb", "else", ":", "dx_ext1", "=", "dx0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dy_ext1", "=", "dy0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dz_ext1", "=", "dz0", "-", "2", "-", "2", "*", "SQUISH_CONSTANT_3D", "xsv_ext1", "=", "xsb", "ysv_ext1", "=", "ysb", "zsv_ext1", "=", "zsb", "+", "2", "else", ":", "# Both closest points on (0,0,0) side", "# One of the two extra points is (0,0,0)", "dx_ext0", "=", "dx0", "dy_ext0", "=", "dy0", "dz_ext0", "=", "dz0", "xsv_ext0", "=", "xsb", "ysv_ext0", "=", "ysb", "zsv_ext0", "=", "zsb", "# Other extra point is based on the omitted axis.", "c", "=", "(", "a_point", "|", "b_point", ")", "if", "(", "c", "&", "0x01", ")", "==", "0", ":", "dx_ext1", "=", "dx0", "+", "1", "-", "SQUISH_CONSTANT_3D", "dy_ext1", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dz_ext1", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_3D", "xsv_ext1", "=", "xsb", "-", "1", "ysv_ext1", "=", "ysb", "+", "1", "zsv_ext1", "=", "zsb", "+", "1", "elif", "(", "c", "&", "0x02", ")", "==", "0", ":", "dx_ext1", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dy_ext1", "=", "dy0", "+", "1", "-", "SQUISH_CONSTANT_3D", "dz_ext1", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_3D", "xsv_ext1", "=", "xsb", "+", "1", "ysv_ext1", "=", "ysb", "-", "1", "zsv_ext1", "=", "zsb", "+", "1", "else", ":", "dx_ext1", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dy_ext1", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dz_ext1", "=", "dz0", "+", "1", "-", "SQUISH_CONSTANT_3D", "xsv_ext1", "=", "xsb", "+", "1", "ysv_ext1", "=", "ysb", "+", "1", "zsv_ext1", "=", "zsb", "-", "1", "else", ":", "# One point on (0,0,0) side, one point on (1,1,1) side", "if", "a_is_further_side", ":", "c1", "=", "a_point", "c2", "=", "b_point", "else", ":", "c1", "=", "b_point", "c2", "=", "a_point", "# One contribution is a _permutation of (1,1,-1)", "if", "(", "c1", "&", "0x01", ")", "==", "0", ":", "dx_ext0", "=", "dx0", "+", "1", "-", "SQUISH_CONSTANT_3D", "dy_ext0", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dz_ext0", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_3D", "xsv_ext0", "=", "xsb", "-", "1", "ysv_ext0", "=", "ysb", "+", "1", "zsv_ext0", "=", "zsb", "+", "1", "elif", "(", "c1", "&", "0x02", ")", "==", "0", ":", "dx_ext0", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dy_ext0", "=", "dy0", "+", "1", "-", "SQUISH_CONSTANT_3D", "dz_ext0", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_3D", "xsv_ext0", "=", "xsb", "+", "1", "ysv_ext0", "=", "ysb", "-", "1", "zsv_ext0", "=", "zsb", "+", "1", "else", ":", "dx_ext0", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dy_ext0", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dz_ext0", "=", "dz0", "+", "1", "-", "SQUISH_CONSTANT_3D", "xsv_ext0", "=", "xsb", "+", "1", "ysv_ext0", "=", "ysb", "+", "1", "zsv_ext0", "=", "zsb", "-", "1", "# One contribution is a _permutation of (0,0,2)", "dx_ext1", "=", "dx0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dy_ext1", "=", "dy0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dz_ext1", "=", "dz0", "-", "2", "*", "SQUISH_CONSTANT_3D", "xsv_ext1", "=", "xsb", "ysv_ext1", "=", "ysb", "zsv_ext1", "=", "zsb", "if", "(", "c2", "&", "0x01", ")", "!=", "0", ":", "dx_ext1", "-=", "2", "xsv_ext1", "+=", "2", "elif", "(", "c2", "&", "0x02", ")", "!=", "0", ":", "dy_ext1", "-=", "2", "ysv_ext1", "+=", "2", "else", ":", "dz_ext1", "-=", "2", "zsv_ext1", "+=", "2", "# Contribution (1,0,0)", "dx1", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dy1", "=", "dy0", "-", "0", "-", "SQUISH_CONSTANT_3D", "dz1", "=", "dz0", "-", "0", "-", "SQUISH_CONSTANT_3D", "attn1", "=", "2", "-", "dx1", "*", "dx1", "-", "dy1", "*", "dy1", "-", "dz1", "*", "dz1", "if", "attn1", ">", "0", ":", "attn1", "*=", "attn1", "value", "+=", "attn1", "*", "attn1", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "zsb", "+", "0", ",", "dx1", ",", "dy1", ",", "dz1", ")", "# Contribution (0,1,0)", "dx2", "=", "dx0", "-", "0", "-", "SQUISH_CONSTANT_3D", "dy2", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_3D", "dz2", "=", "dz1", "attn2", "=", "2", "-", "dx2", "*", "dx2", "-", "dy2", "*", "dy2", "-", "dz2", "*", "dz2", "if", "attn2", ">", "0", ":", "attn2", "*=", "attn2", "value", "+=", "attn2", "*", "attn2", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "zsb", "+", "0", ",", "dx2", ",", "dy2", ",", "dz2", ")", "# Contribution (0,0,1)", "dx3", "=", "dx2", "dy3", "=", "dy1", "dz3", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_3D", "attn3", "=", "2", "-", "dx3", "*", "dx3", "-", "dy3", "*", "dy3", "-", "dz3", "*", "dz3", "if", "attn3", ">", "0", ":", "attn3", "*=", "attn3", "value", "+=", "attn3", "*", "attn3", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "0", ",", "zsb", "+", "1", ",", "dx3", ",", "dy3", ",", "dz3", ")", "# Contribution (1,1,0)", "dx4", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_3D", "dy4", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_3D", "dz4", "=", "dz0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_3D", "attn4", "=", "2", "-", "dx4", "*", "dx4", "-", "dy4", "*", "dy4", "-", "dz4", "*", "dz4", "if", "attn4", ">", "0", ":", "attn4", "*=", "attn4", "value", "+=", "attn4", "*", "attn4", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "1", ",", "zsb", "+", "0", ",", "dx4", ",", "dy4", ",", "dz4", ")", "# Contribution (1,0,1)", "dx5", "=", "dx4", "dy5", "=", "dy0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dz5", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_3D", "attn5", "=", "2", "-", "dx5", "*", "dx5", "-", "dy5", "*", "dy5", "-", "dz5", "*", "dz5", "if", "attn5", ">", "0", ":", "attn5", "*=", "attn5", "value", "+=", "attn5", "*", "attn5", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "zsb", "+", "1", ",", "dx5", ",", "dy5", ",", "dz5", ")", "# Contribution (0,1,1)", "dx6", "=", "dx0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_3D", "dy6", "=", "dy4", "dz6", "=", "dz5", "attn6", "=", "2", "-", "dx6", "*", "dx6", "-", "dy6", "*", "dy6", "-", "dz6", "*", "dz6", "if", "attn6", ">", "0", ":", "attn6", "*=", "attn6", "value", "+=", "attn6", "*", "attn6", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "zsb", "+", "1", ",", "dx6", ",", "dy6", ",", "dz6", ")", "# First extra vertex", "attn_ext0", "=", "2", "-", "dx_ext0", "*", "dx_ext0", "-", "dy_ext0", "*", "dy_ext0", "-", "dz_ext0", "*", "dz_ext0", "if", "attn_ext0", ">", "0", ":", "attn_ext0", "*=", "attn_ext0", "value", "+=", "attn_ext0", "*", "attn_ext0", "*", "extrapolate", "(", "xsv_ext0", ",", "ysv_ext0", ",", "zsv_ext0", ",", "dx_ext0", ",", "dy_ext0", ",", "dz_ext0", ")", "# Second extra vertex", "attn_ext1", "=", "2", "-", "dx_ext1", "*", "dx_ext1", "-", "dy_ext1", "*", "dy_ext1", "-", "dz_ext1", "*", "dz_ext1", "if", "attn_ext1", ">", "0", ":", "attn_ext1", "*=", "attn_ext1", "value", "+=", "attn_ext1", "*", "attn_ext1", "*", "extrapolate", "(", "xsv_ext1", ",", "ysv_ext1", ",", "zsv_ext1", ",", "dx_ext1", ",", "dy_ext1", ",", "dz_ext1", ")", "return", "value", "/", "NORM_CONSTANT_3D" ]

[ "Generate", "3D", "OpenSimplex", "noise", "from", "X", "Y", "Z", "coordinates", "." ]

[ "def", "noise4d", "(", "self", ",", "x", ",", "y", ",", "z", ",", "w", ")", ":", "# Place input coordinates on simplectic honeycomb.", "stretch_offset", "=", "(", "x", "+", "y", "+", "z", "+", "w", ")", "*", "STRETCH_CONSTANT_4D", "xs", "=", "x", "+", "stretch_offset", "ys", "=", "y", "+", "stretch_offset", "zs", "=", "z", "+", "stretch_offset", "ws", "=", "w", "+", "stretch_offset", "# Floor to get simplectic honeycomb coordinates of rhombo-hypercube super-cell origin.", "xsb", "=", "floor", "(", "xs", ")", "ysb", "=", "floor", "(", "ys", ")", "zsb", "=", "floor", "(", "zs", ")", "wsb", "=", "floor", "(", "ws", ")", "# Skew out to get actual coordinates of stretched rhombo-hypercube origin. We'll need these later.", "squish_offset", "=", "(", "xsb", "+", "ysb", "+", "zsb", "+", "wsb", ")", "*", "SQUISH_CONSTANT_4D", "xb", "=", "xsb", "+", "squish_offset", "yb", "=", "ysb", "+", "squish_offset", "zb", "=", "zsb", "+", "squish_offset", "wb", "=", "wsb", "+", "squish_offset", "# Compute simplectic honeycomb coordinates relative to rhombo-hypercube origin.", "xins", "=", "xs", "-", "xsb", "yins", "=", "ys", "-", "ysb", "zins", "=", "zs", "-", "zsb", "wins", "=", "ws", "-", "wsb", "# Sum those together to get a value that determines which region we're in.", "in_sum", "=", "xins", "+", "yins", "+", "zins", "+", "wins", "# Positions relative to origin po.", "dx0", "=", "x", "-", "xb", "dy0", "=", "y", "-", "yb", "dz0", "=", "z", "-", "zb", "dw0", "=", "w", "-", "wb", "value", "=", "0", "extrapolate", "=", "self", ".", "_extrapolate4d", "if", "in_sum", "<=", "1", ":", "# We're inside the pentachoron (4-Simplex) at (0,0,0,0)", "# Determine which two of (0,0,0,1), (0,0,1,0), (0,1,0,0), (1,0,0,0) are closest.", "a_po", "=", "0x01", "a_score", "=", "xins", "b_po", "=", "0x02", "b_score", "=", "yins", "if", "a_score", ">=", "b_score", "and", "zins", ">", "b_score", ":", "b_score", "=", "zins", "b_po", "=", "0x04", "elif", "a_score", "<", "b_score", "and", "zins", ">", "a_score", ":", "a_score", "=", "zins", "a_po", "=", "0x04", "if", "a_score", ">=", "b_score", "and", "wins", ">", "b_score", ":", "b_score", "=", "wins", "b_po", "=", "0x08", "elif", "a_score", "<", "b_score", "and", "wins", ">", "a_score", ":", "a_score", "=", "wins", "a_po", "=", "0x08", "# Now we determine the three lattice pos not part of the pentachoron that may contribute.", "# This depends on the closest two pentachoron vertices, including (0,0,0,0)", "uins", "=", "1", "-", "in_sum", "if", "uins", ">", "a_score", "or", "uins", ">", "b_score", ":", "# (0,0,0,0) is one of the closest two pentachoron vertices.", "c", "=", "b_po", "if", "(", "b_score", ">", "a_score", ")", "else", "a_po", "# Our other closest vertex is the closest out of a and b.", "if", "(", "c", "&", "0x01", ")", "==", "0", ":", "xsv_ext0", "=", "xsb", "-", "1", "xsv_ext1", "=", "xsv_ext2", "=", "xsb", "dx_ext0", "=", "dx0", "+", "1", "dx_ext1", "=", "dx_ext2", "=", "dx0", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsv_ext2", "=", "xsb", "+", "1", "dx_ext0", "=", "dx_ext1", "=", "dx_ext2", "=", "dx0", "-", "1", "if", "(", "c", "&", "0x02", ")", "==", "0", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysv_ext2", "=", "ysb", "dy_ext0", "=", "dy_ext1", "=", "dy_ext2", "=", "dy0", "if", "(", "c", "&", "0x01", ")", "==", "0x01", ":", "ysv_ext0", "-=", "1", "dy_ext0", "+=", "1", "else", ":", "ysv_ext1", "-=", "1", "dy_ext1", "+=", "1", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysv_ext2", "=", "ysb", "+", "1", "dy_ext0", "=", "dy_ext1", "=", "dy_ext2", "=", "dy0", "-", "1", "if", "(", "c", "&", "0x04", ")", "==", "0", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsv_ext2", "=", "zsb", "dz_ext0", "=", "dz_ext1", "=", "dz_ext2", "=", "dz0", "if", "(", "c", "&", "0x03", ")", "!=", "0", ":", "if", "(", "c", "&", "0x03", ")", "==", "0x03", ":", "zsv_ext0", "-=", "1", "dz_ext0", "+=", "1", "else", ":", "zsv_ext1", "-=", "1", "dz_ext1", "+=", "1", "else", ":", "zsv_ext2", "-=", "1", "dz_ext2", "+=", "1", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsv_ext2", "=", "zsb", "+", "1", "dz_ext0", "=", "dz_ext1", "=", "dz_ext2", "=", "dz0", "-", "1", "if", "(", "c", "&", "0x08", ")", "==", "0", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsb", "wsv_ext2", "=", "wsb", "-", "1", "dw_ext0", "=", "dw_ext1", "=", "dw0", "dw_ext2", "=", "dw0", "+", "1", "else", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsv_ext2", "=", "wsb", "+", "1", "dw_ext0", "=", "dw_ext1", "=", "dw_ext2", "=", "dw0", "-", "1", "else", ":", "# (0,0,0,0) is not one of the closest two pentachoron vertices.", "c", "=", "(", "a_po", "|", "b_po", ")", "# Our three extra vertices are determined by the closest two.", "if", "(", "c", "&", "0x01", ")", "==", "0", ":", "xsv_ext0", "=", "xsv_ext2", "=", "xsb", "xsv_ext1", "=", "xsb", "-", "1", "dx_ext0", "=", "dx0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dx_ext1", "=", "dx0", "+", "1", "-", "SQUISH_CONSTANT_4D", "dx_ext2", "=", "dx0", "-", "SQUISH_CONSTANT_4D", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsv_ext2", "=", "xsb", "+", "1", "dx_ext0", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dx_ext1", "=", "dx_ext2", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x02", ")", "==", "0", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysv_ext2", "=", "ysb", "dy_ext0", "=", "dy0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy_ext1", "=", "dy_ext2", "=", "dy0", "-", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x01", ")", "==", "0x01", ":", "ysv_ext1", "-=", "1", "dy_ext1", "+=", "1", "else", ":", "ysv_ext2", "-=", "1", "dy_ext2", "+=", "1", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysv_ext2", "=", "ysb", "+", "1", "dy_ext0", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy_ext1", "=", "dy_ext2", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x04", ")", "==", "0", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsv_ext2", "=", "zsb", "dz_ext0", "=", "dz0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz_ext1", "=", "dz_ext2", "=", "dz0", "-", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x03", ")", "==", "0x03", ":", "zsv_ext1", "-=", "1", "dz_ext1", "+=", "1", "else", ":", "zsv_ext2", "-=", "1", "dz_ext2", "+=", "1", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsv_ext2", "=", "zsb", "+", "1", "dz_ext0", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz_ext1", "=", "dz_ext2", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x08", ")", "==", "0", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsb", "wsv_ext2", "=", "wsb", "-", "1", "dw_ext0", "=", "dw0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw_ext1", "=", "dw0", "-", "SQUISH_CONSTANT_4D", "dw_ext2", "=", "dw0", "+", "1", "-", "SQUISH_CONSTANT_4D", "else", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsv_ext2", "=", "wsb", "+", "1", "dw_ext0", "=", "dw0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw_ext1", "=", "dw_ext2", "=", "dw0", "-", "1", "-", "SQUISH_CONSTANT_4D", "# Contribution (0,0,0,0)", "attn0", "=", "2", "-", "dx0", "*", "dx0", "-", "dy0", "*", "dy0", "-", "dz0", "*", "dz0", "-", "dw0", "*", "dw0", "if", "attn0", ">", "0", ":", "attn0", "*=", "attn0", "value", "+=", "attn0", "*", "attn0", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "0", ",", "zsb", "+", "0", ",", "wsb", "+", "0", ",", "dx0", ",", "dy0", ",", "dz0", ",", "dw0", ")", "# Contribution (1,0,0,0)", "dx1", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_4D", "dy1", "=", "dy0", "-", "0", "-", "SQUISH_CONSTANT_4D", "dz1", "=", "dz0", "-", "0", "-", "SQUISH_CONSTANT_4D", "dw1", "=", "dw0", "-", "0", "-", "SQUISH_CONSTANT_4D", "attn1", "=", "2", "-", "dx1", "*", "dx1", "-", "dy1", "*", "dy1", "-", "dz1", "*", "dz1", "-", "dw1", "*", "dw1", "if", "attn1", ">", "0", ":", "attn1", "*=", "attn1", "value", "+=", "attn1", "*", "attn1", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "zsb", "+", "0", ",", "wsb", "+", "0", ",", "dx1", ",", "dy1", ",", "dz1", ",", "dw1", ")", "# Contribution (0,1,0,0)", "dx2", "=", "dx0", "-", "0", "-", "SQUISH_CONSTANT_4D", "dy2", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_4D", "dz2", "=", "dz1", "dw2", "=", "dw1", "attn2", "=", "2", "-", "dx2", "*", "dx2", "-", "dy2", "*", "dy2", "-", "dz2", "*", "dz2", "-", "dw2", "*", "dw2", "if", "attn2", ">", "0", ":", "attn2", "*=", "attn2", "value", "+=", "attn2", "*", "attn2", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "zsb", "+", "0", ",", "wsb", "+", "0", ",", "dx2", ",", "dy2", ",", "dz2", ",", "dw2", ")", "# Contribution (0,0,1,0)", "dx3", "=", "dx2", "dy3", "=", "dy1", "dz3", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_4D", "dw3", "=", "dw1", "attn3", "=", "2", "-", "dx3", "*", "dx3", "-", "dy3", "*", "dy3", "-", "dz3", "*", "dz3", "-", "dw3", "*", "dw3", "if", "attn3", ">", "0", ":", "attn3", "*=", "attn3", "value", "+=", "attn3", "*", "attn3", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "0", ",", "zsb", "+", "1", ",", "wsb", "+", "0", ",", "dx3", ",", "dy3", ",", "dz3", ",", "dw3", ")", "# Contribution (0,0,0,1)", "dx4", "=", "dx2", "dy4", "=", "dy1", "dz4", "=", "dz1", "dw4", "=", "dw0", "-", "1", "-", "SQUISH_CONSTANT_4D", "attn4", "=", "2", "-", "dx4", "*", "dx4", "-", "dy4", "*", "dy4", "-", "dz4", "*", "dz4", "-", "dw4", "*", "dw4", "if", "attn4", ">", "0", ":", "attn4", "*=", "attn4", "value", "+=", "attn4", "*", "attn4", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "0", ",", "zsb", "+", "0", ",", "wsb", "+", "1", ",", "dx4", ",", "dy4", ",", "dz4", ",", "dw4", ")", "elif", "in_sum", ">=", "3", ":", "# We're inside the pentachoron (4-Simplex) at (1,1,1,1)", "# Determine which two of (1,1,1,0), (1,1,0,1), (1,0,1,1), (0,1,1,1) are closest.", "a_po", "=", "0x0E", "a_score", "=", "xins", "b_po", "=", "0x0D", "b_score", "=", "yins", "if", "a_score", "<=", "b_score", "and", "zins", "<", "b_score", ":", "b_score", "=", "zins", "b_po", "=", "0x0B", "elif", "a_score", ">", "b_score", "and", "zins", "<", "a_score", ":", "a_score", "=", "zins", "a_po", "=", "0x0B", "if", "a_score", "<=", "b_score", "and", "wins", "<", "b_score", ":", "b_score", "=", "wins", "b_po", "=", "0x07", "elif", "a_score", ">", "b_score", "and", "wins", "<", "a_score", ":", "a_score", "=", "wins", "a_po", "=", "0x07", "# Now we determine the three lattice pos not part of the pentachoron that may contribute.", "# This depends on the closest two pentachoron vertices, including (0,0,0,0)", "uins", "=", "4", "-", "in_sum", "if", "uins", "<", "a_score", "or", "uins", "<", "b_score", ":", "# (1,1,1,1) is one of the closest two pentachoron vertices.", "c", "=", "b_po", "if", "(", "b_score", "<", "a_score", ")", "else", "a_po", "# Our other closest vertex is the closest out of a and b.", "if", "(", "c", "&", "0x01", ")", "!=", "0", ":", "xsv_ext0", "=", "xsb", "+", "2", "xsv_ext1", "=", "xsv_ext2", "=", "xsb", "+", "1", "dx_ext0", "=", "dx0", "-", "2", "-", "4", "*", "SQUISH_CONSTANT_4D", "dx_ext1", "=", "dx_ext2", "=", "dx0", "-", "1", "-", "4", "*", "SQUISH_CONSTANT_4D", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsv_ext2", "=", "xsb", "dx_ext0", "=", "dx_ext1", "=", "dx_ext2", "=", "dx0", "-", "4", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x02", ")", "!=", "0", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysv_ext2", "=", "ysb", "+", "1", "dy_ext0", "=", "dy_ext1", "=", "dy_ext2", "=", "dy0", "-", "1", "-", "4", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x01", ")", "!=", "0", ":", "ysv_ext1", "+=", "1", "dy_ext1", "-=", "1", "else", ":", "ysv_ext0", "+=", "1", "dy_ext0", "-=", "1", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysv_ext2", "=", "ysb", "dy_ext0", "=", "dy_ext1", "=", "dy_ext2", "=", "dy0", "-", "4", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x04", ")", "!=", "0", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsv_ext2", "=", "zsb", "+", "1", "dz_ext0", "=", "dz_ext1", "=", "dz_ext2", "=", "dz0", "-", "1", "-", "4", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x03", ")", "!=", "0x03", ":", "if", "(", "c", "&", "0x03", ")", "==", "0", ":", "zsv_ext0", "+=", "1", "dz_ext0", "-=", "1", "else", ":", "zsv_ext1", "+=", "1", "dz_ext1", "-=", "1", "else", ":", "zsv_ext2", "+=", "1", "dz_ext2", "-=", "1", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsv_ext2", "=", "zsb", "dz_ext0", "=", "dz_ext1", "=", "dz_ext2", "=", "dz0", "-", "4", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x08", ")", "!=", "0", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsb", "+", "1", "wsv_ext2", "=", "wsb", "+", "2", "dw_ext0", "=", "dw_ext1", "=", "dw0", "-", "1", "-", "4", "*", "SQUISH_CONSTANT_4D", "dw_ext2", "=", "dw0", "-", "2", "-", "4", "*", "SQUISH_CONSTANT_4D", "else", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsv_ext2", "=", "wsb", "dw_ext0", "=", "dw_ext1", "=", "dw_ext2", "=", "dw0", "-", "4", "*", "SQUISH_CONSTANT_4D", "else", ":", "# (1,1,1,1) is not one of the closest two pentachoron vertices.", "c", "=", "(", "a_po", "&", "b_po", ")", "# Our three extra vertices are determined by the closest two.", "if", "(", "c", "&", "0x01", ")", "!=", "0", ":", "xsv_ext0", "=", "xsv_ext2", "=", "xsb", "+", "1", "xsv_ext1", "=", "xsb", "+", "2", "dx_ext0", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dx_ext1", "=", "dx0", "-", "2", "-", "3", "*", "SQUISH_CONSTANT_4D", "dx_ext2", "=", "dx0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsv_ext2", "=", "xsb", "dx_ext0", "=", "dx0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dx_ext1", "=", "dx_ext2", "=", "dx0", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x02", ")", "!=", "0", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysv_ext2", "=", "ysb", "+", "1", "dy_ext0", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy_ext1", "=", "dy_ext2", "=", "dy0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x01", ")", "!=", "0", ":", "ysv_ext2", "+=", "1", "dy_ext2", "-=", "1", "else", ":", "ysv_ext1", "+=", "1", "dy_ext1", "-=", "1", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysv_ext2", "=", "ysb", "dy_ext0", "=", "dy0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy_ext1", "=", "dy_ext2", "=", "dy0", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x04", ")", "!=", "0", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsv_ext2", "=", "zsb", "+", "1", "dz_ext0", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz_ext1", "=", "dz_ext2", "=", "dz0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x03", ")", "!=", "0", ":", "zsv_ext2", "+=", "1", "dz_ext2", "-=", "1", "else", ":", "zsv_ext1", "+=", "1", "dz_ext1", "-=", "1", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsv_ext2", "=", "zsb", "dz_ext0", "=", "dz0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz_ext1", "=", "dz_ext2", "=", "dz0", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x08", ")", "!=", "0", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsb", "+", "1", "wsv_ext2", "=", "wsb", "+", "2", "dw_ext0", "=", "dw0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw_ext1", "=", "dw0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dw_ext2", "=", "dw0", "-", "2", "-", "3", "*", "SQUISH_CONSTANT_4D", "else", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsv_ext2", "=", "wsb", "dw_ext0", "=", "dw0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw_ext1", "=", "dw_ext2", "=", "dw0", "-", "3", "*", "SQUISH_CONSTANT_4D", "# Contribution (1,1,1,0)", "dx4", "=", "dx0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dy4", "=", "dy0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dz4", "=", "dz0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dw4", "=", "dw0", "-", "3", "*", "SQUISH_CONSTANT_4D", "attn4", "=", "2", "-", "dx4", "*", "dx4", "-", "dy4", "*", "dy4", "-", "dz4", "*", "dz4", "-", "dw4", "*", "dw4", "if", "attn4", ">", "0", ":", "attn4", "*=", "attn4", "value", "+=", "attn4", "*", "attn4", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "1", ",", "zsb", "+", "1", ",", "wsb", "+", "0", ",", "dx4", ",", "dy4", ",", "dz4", ",", "dw4", ")", "# Contribution (1,1,0,1)", "dx3", "=", "dx4", "dy3", "=", "dy4", "dz3", "=", "dz0", "-", "3", "*", "SQUISH_CONSTANT_4D", "dw3", "=", "dw0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "attn3", "=", "2", "-", "dx3", "*", "dx3", "-", "dy3", "*", "dy3", "-", "dz3", "*", "dz3", "-", "dw3", "*", "dw3", "if", "attn3", ">", "0", ":", "attn3", "*=", "attn3", "value", "+=", "attn3", "*", "attn3", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "1", ",", "zsb", "+", "0", ",", "wsb", "+", "1", ",", "dx3", ",", "dy3", ",", "dz3", ",", "dw3", ")", "# Contribution (1,0,1,1)", "dx2", "=", "dx4", "dy2", "=", "dy0", "-", "3", "*", "SQUISH_CONSTANT_4D", "dz2", "=", "dz4", "dw2", "=", "dw3", "attn2", "=", "2", "-", "dx2", "*", "dx2", "-", "dy2", "*", "dy2", "-", "dz2", "*", "dz2", "-", "dw2", "*", "dw2", "if", "attn2", ">", "0", ":", "attn2", "*=", "attn2", "value", "+=", "attn2", "*", "attn2", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "zsb", "+", "1", ",", "wsb", "+", "1", ",", "dx2", ",", "dy2", ",", "dz2", ",", "dw2", ")", "# Contribution (0,1,1,1)", "dx1", "=", "dx0", "-", "3", "*", "SQUISH_CONSTANT_4D", "dz1", "=", "dz4", "dy1", "=", "dy4", "dw1", "=", "dw3", "attn1", "=", "2", "-", "dx1", "*", "dx1", "-", "dy1", "*", "dy1", "-", "dz1", "*", "dz1", "-", "dw1", "*", "dw1", "if", "attn1", ">", "0", ":", "attn1", "*=", "attn1", "value", "+=", "attn1", "*", "attn1", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "zsb", "+", "1", ",", "wsb", "+", "1", ",", "dx1", ",", "dy1", ",", "dz1", ",", "dw1", ")", "# Contribution (1,1,1,1)", "dx0", "=", "dx0", "-", "1", "-", "4", "*", "SQUISH_CONSTANT_4D", "dy0", "=", "dy0", "-", "1", "-", "4", "*", "SQUISH_CONSTANT_4D", "dz0", "=", "dz0", "-", "1", "-", "4", "*", "SQUISH_CONSTANT_4D", "dw0", "=", "dw0", "-", "1", "-", "4", "*", "SQUISH_CONSTANT_4D", "attn0", "=", "2", "-", "dx0", "*", "dx0", "-", "dy0", "*", "dy0", "-", "dz0", "*", "dz0", "-", "dw0", "*", "dw0", "if", "attn0", ">", "0", ":", "attn0", "*=", "attn0", "value", "+=", "attn0", "*", "attn0", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "1", ",", "zsb", "+", "1", ",", "wsb", "+", "1", ",", "dx0", ",", "dy0", ",", "dz0", ",", "dw0", ")", "elif", "in_sum", "<=", "2", ":", "# We're inside the first dispentachoron (Rectified 4-Simplex)", "a_is_bigger_side", "=", "True", "b_is_bigger_side", "=", "True", "# Decide between (1,1,0,0) and (0,0,1,1)", "if", "xins", "+", "yins", ">", "zins", "+", "wins", ":", "a_score", "=", "xins", "+", "yins", "a_po", "=", "0x03", "else", ":", "a_score", "=", "zins", "+", "wins", "a_po", "=", "0x0C", "# Decide between (1,0,1,0) and (0,1,0,1)", "if", "xins", "+", "zins", ">", "yins", "+", "wins", ":", "b_score", "=", "xins", "+", "zins", "b_po", "=", "0x05", "else", ":", "b_score", "=", "yins", "+", "wins", "b_po", "=", "0x0A", "# Closer between (1,0,0,1) and (0,1,1,0) will replace the further of a and b, if closer.", "if", "xins", "+", "wins", ">", "yins", "+", "zins", ":", "score", "=", "xins", "+", "wins", "if", "a_score", ">=", "b_score", "and", "score", ">", "b_score", ":", "b_score", "=", "score", "b_po", "=", "0x09", "elif", "a_score", "<", "b_score", "and", "score", ">", "a_score", ":", "a_score", "=", "score", "a_po", "=", "0x09", "else", ":", "score", "=", "yins", "+", "zins", "if", "a_score", ">=", "b_score", "and", "score", ">", "b_score", ":", "b_score", "=", "score", "b_po", "=", "0x06", "elif", "a_score", "<", "b_score", "and", "score", ">", "a_score", ":", "a_score", "=", "score", "a_po", "=", "0x06", "# Decide if (1,0,0,0) is closer.", "p1", "=", "2", "-", "in_sum", "+", "xins", "if", "a_score", ">=", "b_score", "and", "p1", ">", "b_score", ":", "b_score", "=", "p1", "b_po", "=", "0x01", "b_is_bigger_side", "=", "False", "elif", "a_score", "<", "b_score", "and", "p1", ">", "a_score", ":", "a_score", "=", "p1", "a_po", "=", "0x01", "a_is_bigger_side", "=", "False", "# Decide if (0,1,0,0) is closer.", "p2", "=", "2", "-", "in_sum", "+", "yins", "if", "a_score", ">=", "b_score", "and", "p2", ">", "b_score", ":", "b_score", "=", "p2", "b_po", "=", "0x02", "b_is_bigger_side", "=", "False", "elif", "a_score", "<", "b_score", "and", "p2", ">", "a_score", ":", "a_score", "=", "p2", "a_po", "=", "0x02", "a_is_bigger_side", "=", "False", "# Decide if (0,0,1,0) is closer.", "p3", "=", "2", "-", "in_sum", "+", "zins", "if", "a_score", ">=", "b_score", "and", "p3", ">", "b_score", ":", "b_score", "=", "p3", "b_po", "=", "0x04", "b_is_bigger_side", "=", "False", "elif", "a_score", "<", "b_score", "and", "p3", ">", "a_score", ":", "a_score", "=", "p3", "a_po", "=", "0x04", "a_is_bigger_side", "=", "False", "# Decide if (0,0,0,1) is closer.", "p4", "=", "2", "-", "in_sum", "+", "wins", "if", "a_score", ">=", "b_score", "and", "p4", ">", "b_score", ":", "b_po", "=", "0x08", "b_is_bigger_side", "=", "False", "elif", "a_score", "<", "b_score", "and", "p4", ">", "a_score", ":", "a_po", "=", "0x08", "a_is_bigger_side", "=", "False", "# Where each of the two closest pos are determines how the extra three vertices are calculated.", "if", "a_is_bigger_side", "==", "b_is_bigger_side", ":", "if", "a_is_bigger_side", ":", "# Both closest pos on the bigger side", "c1", "=", "(", "a_po", "|", "b_po", ")", "c2", "=", "(", "a_po", "&", "b_po", ")", "if", "(", "c1", "&", "0x01", ")", "==", "0", ":", "xsv_ext0", "=", "xsb", "xsv_ext1", "=", "xsb", "-", "1", "dx_ext0", "=", "dx0", "-", "3", "*", "SQUISH_CONSTANT_4D", "dx_ext1", "=", "dx0", "+", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsb", "+", "1", "dx_ext0", "=", "dx0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dx_ext1", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x02", ")", "==", "0", ":", "ysv_ext0", "=", "ysb", "ysv_ext1", "=", "ysb", "-", "1", "dy_ext0", "=", "dy0", "-", "3", "*", "SQUISH_CONSTANT_4D", "dy_ext1", "=", "dy0", "+", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "+", "1", "dy_ext0", "=", "dy0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dy_ext1", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x04", ")", "==", "0", ":", "zsv_ext0", "=", "zsb", "zsv_ext1", "=", "zsb", "-", "1", "dz_ext0", "=", "dz0", "-", "3", "*", "SQUISH_CONSTANT_4D", "dz_ext1", "=", "dz0", "+", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "+", "1", "dz_ext0", "=", "dz0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dz_ext1", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x08", ")", "==", "0", ":", "wsv_ext0", "=", "wsb", "wsv_ext1", "=", "wsb", "-", "1", "dw_ext0", "=", "dw0", "-", "3", "*", "SQUISH_CONSTANT_4D", "dw_ext1", "=", "dw0", "+", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "else", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsb", "+", "1", "dw_ext0", "=", "dw0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dw_ext1", "=", "dw0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "# One combination is a _permutation of (0,0,0,2) based on c2", "xsv_ext2", "=", "xsb", "ysv_ext2", "=", "ysb", "zsv_ext2", "=", "zsb", "wsv_ext2", "=", "wsb", "dx_ext2", "=", "dx0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy_ext2", "=", "dy0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz_ext2", "=", "dz0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw_ext2", "=", "dw0", "-", "2", "*", "SQUISH_CONSTANT_4D", "if", "(", "c2", "&", "0x01", ")", "!=", "0", ":", "xsv_ext2", "+=", "2", "dx_ext2", "-=", "2", "elif", "(", "c2", "&", "0x02", ")", "!=", "0", ":", "ysv_ext2", "+=", "2", "dy_ext2", "-=", "2", "elif", "(", "c2", "&", "0x04", ")", "!=", "0", ":", "zsv_ext2", "+=", "2", "dz_ext2", "-=", "2", "else", ":", "wsv_ext2", "+=", "2", "dw_ext2", "-=", "2", "else", ":", "# Both closest pos on the smaller side", "# One of the two extra pos is (0,0,0,0)", "xsv_ext2", "=", "xsb", "ysv_ext2", "=", "ysb", "zsv_ext2", "=", "zsb", "wsv_ext2", "=", "wsb", "dx_ext2", "=", "dx0", "dy_ext2", "=", "dy0", "dz_ext2", "=", "dz0", "dw_ext2", "=", "dw0", "# Other two pos are based on the omitted axes.", "c", "=", "(", "a_po", "|", "b_po", ")", "if", "(", "c", "&", "0x01", ")", "==", "0", ":", "xsv_ext0", "=", "xsb", "-", "1", "xsv_ext1", "=", "xsb", "dx_ext0", "=", "dx0", "+", "1", "-", "SQUISH_CONSTANT_4D", "dx_ext1", "=", "dx0", "-", "SQUISH_CONSTANT_4D", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsb", "+", "1", "dx_ext0", "=", "dx_ext1", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x02", ")", "==", "0", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "dy_ext0", "=", "dy_ext1", "=", "dy0", "-", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x01", ")", "==", "0x01", ":", "ysv_ext0", "-=", "1", "dy_ext0", "+=", "1", "else", ":", "ysv_ext1", "-=", "1", "dy_ext1", "+=", "1", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "+", "1", "dy_ext0", "=", "dy_ext1", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x04", ")", "==", "0", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "dz_ext0", "=", "dz_ext1", "=", "dz0", "-", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x03", ")", "==", "0x03", ":", "zsv_ext0", "-=", "1", "dz_ext0", "+=", "1", "else", ":", "zsv_ext1", "-=", "1", "dz_ext1", "+=", "1", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "+", "1", "dz_ext0", "=", "dz_ext1", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x08", ")", "==", "0", ":", "wsv_ext0", "=", "wsb", "wsv_ext1", "=", "wsb", "-", "1", "dw_ext0", "=", "dw0", "-", "SQUISH_CONSTANT_4D", "dw_ext1", "=", "dw0", "+", "1", "-", "SQUISH_CONSTANT_4D", "else", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsb", "+", "1", "dw_ext0", "=", "dw_ext1", "=", "dw0", "-", "1", "-", "SQUISH_CONSTANT_4D", "else", ":", "# One po on each \"side\"", "if", "a_is_bigger_side", ":", "c1", "=", "a_po", "c2", "=", "b_po", "else", ":", "c1", "=", "b_po", "c2", "=", "a_po", "# Two contributions are the bigger-sided po with each 0 replaced with -1.", "if", "(", "c1", "&", "0x01", ")", "==", "0", ":", "xsv_ext0", "=", "xsb", "-", "1", "xsv_ext1", "=", "xsb", "dx_ext0", "=", "dx0", "+", "1", "-", "SQUISH_CONSTANT_4D", "dx_ext1", "=", "dx0", "-", "SQUISH_CONSTANT_4D", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsb", "+", "1", "dx_ext0", "=", "dx_ext1", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x02", ")", "==", "0", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "dy_ext0", "=", "dy_ext1", "=", "dy0", "-", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x01", ")", "==", "0x01", ":", "ysv_ext0", "-=", "1", "dy_ext0", "+=", "1", "else", ":", "ysv_ext1", "-=", "1", "dy_ext1", "+=", "1", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "+", "1", "dy_ext0", "=", "dy_ext1", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x04", ")", "==", "0", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "dz_ext0", "=", "dz_ext1", "=", "dz0", "-", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x03", ")", "==", "0x03", ":", "zsv_ext0", "-=", "1", "dz_ext0", "+=", "1", "else", ":", "zsv_ext1", "-=", "1", "dz_ext1", "+=", "1", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "+", "1", "dz_ext0", "=", "dz_ext1", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x08", ")", "==", "0", ":", "wsv_ext0", "=", "wsb", "wsv_ext1", "=", "wsb", "-", "1", "dw_ext0", "=", "dw0", "-", "SQUISH_CONSTANT_4D", "dw_ext1", "=", "dw0", "+", "1", "-", "SQUISH_CONSTANT_4D", "else", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsb", "+", "1", "dw_ext0", "=", "dw_ext1", "=", "dw0", "-", "1", "-", "SQUISH_CONSTANT_4D", "# One contribution is a _permutation of (0,0,0,2) based on the smaller-sided po", "xsv_ext2", "=", "xsb", "ysv_ext2", "=", "ysb", "zsv_ext2", "=", "zsb", "wsv_ext2", "=", "wsb", "dx_ext2", "=", "dx0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy_ext2", "=", "dy0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz_ext2", "=", "dz0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw_ext2", "=", "dw0", "-", "2", "*", "SQUISH_CONSTANT_4D", "if", "(", "c2", "&", "0x01", ")", "!=", "0", ":", "xsv_ext2", "+=", "2", "dx_ext2", "-=", "2", "elif", "(", "c2", "&", "0x02", ")", "!=", "0", ":", "ysv_ext2", "+=", "2", "dy_ext2", "-=", "2", "elif", "(", "c2", "&", "0x04", ")", "!=", "0", ":", "zsv_ext2", "+=", "2", "dz_ext2", "-=", "2", "else", ":", "wsv_ext2", "+=", "2", "dw_ext2", "-=", "2", "# Contribution (1,0,0,0)", "dx1", "=", "dx0", "-", "1", "-", "SQUISH_CONSTANT_4D", "dy1", "=", "dy0", "-", "0", "-", "SQUISH_CONSTANT_4D", "dz1", "=", "dz0", "-", "0", "-", "SQUISH_CONSTANT_4D", "dw1", "=", "dw0", "-", "0", "-", "SQUISH_CONSTANT_4D", "attn1", "=", "2", "-", "dx1", "*", "dx1", "-", "dy1", "*", "dy1", "-", "dz1", "*", "dz1", "-", "dw1", "*", "dw1", "if", "attn1", ">", "0", ":", "attn1", "*=", "attn1", "value", "+=", "attn1", "*", "attn1", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "zsb", "+", "0", ",", "wsb", "+", "0", ",", "dx1", ",", "dy1", ",", "dz1", ",", "dw1", ")", "# Contribution (0,1,0,0)", "dx2", "=", "dx0", "-", "0", "-", "SQUISH_CONSTANT_4D", "dy2", "=", "dy0", "-", "1", "-", "SQUISH_CONSTANT_4D", "dz2", "=", "dz1", "dw2", "=", "dw1", "attn2", "=", "2", "-", "dx2", "*", "dx2", "-", "dy2", "*", "dy2", "-", "dz2", "*", "dz2", "-", "dw2", "*", "dw2", "if", "attn2", ">", "0", ":", "attn2", "*=", "attn2", "value", "+=", "attn2", "*", "attn2", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "zsb", "+", "0", ",", "wsb", "+", "0", ",", "dx2", ",", "dy2", ",", "dz2", ",", "dw2", ")", "# Contribution (0,0,1,0)", "dx3", "=", "dx2", "dy3", "=", "dy1", "dz3", "=", "dz0", "-", "1", "-", "SQUISH_CONSTANT_4D", "dw3", "=", "dw1", "attn3", "=", "2", "-", "dx3", "*", "dx3", "-", "dy3", "*", "dy3", "-", "dz3", "*", "dz3", "-", "dw3", "*", "dw3", "if", "attn3", ">", "0", ":", "attn3", "*=", "attn3", "value", "+=", "attn3", "*", "attn3", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "0", ",", "zsb", "+", "1", ",", "wsb", "+", "0", ",", "dx3", ",", "dy3", ",", "dz3", ",", "dw3", ")", "# Contribution (0,0,0,1)", "dx4", "=", "dx2", "dy4", "=", "dy1", "dz4", "=", "dz1", "dw4", "=", "dw0", "-", "1", "-", "SQUISH_CONSTANT_4D", "attn4", "=", "2", "-", "dx4", "*", "dx4", "-", "dy4", "*", "dy4", "-", "dz4", "*", "dz4", "-", "dw4", "*", "dw4", "if", "attn4", ">", "0", ":", "attn4", "*=", "attn4", "value", "+=", "attn4", "*", "attn4", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "0", ",", "zsb", "+", "0", ",", "wsb", "+", "1", ",", "dx4", ",", "dy4", ",", "dz4", ",", "dw4", ")", "# Contribution (1,1,0,0)", "dx5", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy5", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz5", "=", "dz0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw5", "=", "dw0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "attn5", "=", "2", "-", "dx5", "*", "dx5", "-", "dy5", "*", "dy5", "-", "dz5", "*", "dz5", "-", "dw5", "*", "dw5", "if", "attn5", ">", "0", ":", "attn5", "*=", "attn5", "value", "+=", "attn5", "*", "attn5", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "1", ",", "zsb", "+", "0", ",", "wsb", "+", "0", ",", "dx5", ",", "dy5", ",", "dz5", ",", "dw5", ")", "# Contribution (1,0,1,0)", "dx6", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy6", "=", "dy0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz6", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw6", "=", "dw0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "attn6", "=", "2", "-", "dx6", "*", "dx6", "-", "dy6", "*", "dy6", "-", "dz6", "*", "dz6", "-", "dw6", "*", "dw6", "if", "attn6", ">", "0", ":", "attn6", "*=", "attn6", "value", "+=", "attn6", "*", "attn6", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "zsb", "+", "1", ",", "wsb", "+", "0", ",", "dx6", ",", "dy6", ",", "dz6", ",", "dw6", ")", "# Contribution (1,0,0,1)", "dx7", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy7", "=", "dy0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz7", "=", "dz0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw7", "=", "dw0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "attn7", "=", "2", "-", "dx7", "*", "dx7", "-", "dy7", "*", "dy7", "-", "dz7", "*", "dz7", "-", "dw7", "*", "dw7", "if", "attn7", ">", "0", ":", "attn7", "*=", "attn7", "value", "+=", "attn7", "*", "attn7", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "zsb", "+", "0", ",", "wsb", "+", "1", ",", "dx7", ",", "dy7", ",", "dz7", ",", "dw7", ")", "# Contribution (0,1,1,0)", "dx8", "=", "dx0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy8", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz8", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw8", "=", "dw0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "attn8", "=", "2", "-", "dx8", "*", "dx8", "-", "dy8", "*", "dy8", "-", "dz8", "*", "dz8", "-", "dw8", "*", "dw8", "if", "attn8", ">", "0", ":", "attn8", "*=", "attn8", "value", "+=", "attn8", "*", "attn8", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "zsb", "+", "1", ",", "wsb", "+", "0", ",", "dx8", ",", "dy8", ",", "dz8", ",", "dw8", ")", "# Contribution (0,1,0,1)", "dx9", "=", "dx0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy9", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz9", "=", "dz0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw9", "=", "dw0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "attn9", "=", "2", "-", "dx9", "*", "dx9", "-", "dy9", "*", "dy9", "-", "dz9", "*", "dz9", "-", "dw9", "*", "dw9", "if", "attn9", ">", "0", ":", "attn9", "*=", "attn9", "value", "+=", "attn9", "*", "attn9", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "zsb", "+", "0", ",", "wsb", "+", "1", ",", "dx9", ",", "dy9", ",", "dz9", ",", "dw9", ")", "# Contribution (0,0,1,1)", "dx10", "=", "dx0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy10", "=", "dy0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz10", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw10", "=", "dw0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "attn10", "=", "2", "-", "dx10", "*", "dx10", "-", "dy10", "*", "dy10", "-", "dz10", "*", "dz10", "-", "dw10", "*", "dw10", "if", "attn10", ">", "0", ":", "attn10", "*=", "attn10", "value", "+=", "attn10", "*", "attn10", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "0", ",", "zsb", "+", "1", ",", "wsb", "+", "1", ",", "dx10", ",", "dy10", ",", "dz10", ",", "dw10", ")", "else", ":", "# We're inside the second dispentachoron (Rectified 4-Simplex)", "a_is_bigger_side", "=", "True", "b_is_bigger_side", "=", "True", "# Decide between (0,0,1,1) and (1,1,0,0)", "if", "xins", "+", "yins", "<", "zins", "+", "wins", ":", "a_score", "=", "xins", "+", "yins", "a_po", "=", "0x0C", "else", ":", "a_score", "=", "zins", "+", "wins", "a_po", "=", "0x03", "# Decide between (0,1,0,1) and (1,0,1,0)", "if", "xins", "+", "zins", "<", "yins", "+", "wins", ":", "b_score", "=", "xins", "+", "zins", "b_po", "=", "0x0A", "else", ":", "b_score", "=", "yins", "+", "wins", "b_po", "=", "0x05", "# Closer between (0,1,1,0) and (1,0,0,1) will replace the further of a and b, if closer.", "if", "xins", "+", "wins", "<", "yins", "+", "zins", ":", "score", "=", "xins", "+", "wins", "if", "a_score", "<=", "b_score", "and", "score", "<", "b_score", ":", "b_score", "=", "score", "b_po", "=", "0x06", "elif", "a_score", ">", "b_score", "and", "score", "<", "a_score", ":", "a_score", "=", "score", "a_po", "=", "0x06", "else", ":", "score", "=", "yins", "+", "zins", "if", "a_score", "<=", "b_score", "and", "score", "<", "b_score", ":", "b_score", "=", "score", "b_po", "=", "0x09", "elif", "a_score", ">", "b_score", "and", "score", "<", "a_score", ":", "a_score", "=", "score", "a_po", "=", "0x09", "# Decide if (0,1,1,1) is closer.", "p1", "=", "3", "-", "in_sum", "+", "xins", "if", "a_score", "<=", "b_score", "and", "p1", "<", "b_score", ":", "b_score", "=", "p1", "b_po", "=", "0x0E", "b_is_bigger_side", "=", "False", "elif", "a_score", ">", "b_score", "and", "p1", "<", "a_score", ":", "a_score", "=", "p1", "a_po", "=", "0x0E", "a_is_bigger_side", "=", "False", "# Decide if (1,0,1,1) is closer.", "p2", "=", "3", "-", "in_sum", "+", "yins", "if", "a_score", "<=", "b_score", "and", "p2", "<", "b_score", ":", "b_score", "=", "p2", "b_po", "=", "0x0D", "b_is_bigger_side", "=", "False", "elif", "a_score", ">", "b_score", "and", "p2", "<", "a_score", ":", "a_score", "=", "p2", "a_po", "=", "0x0D", "a_is_bigger_side", "=", "False", "# Decide if (1,1,0,1) is closer.", "p3", "=", "3", "-", "in_sum", "+", "zins", "if", "a_score", "<=", "b_score", "and", "p3", "<", "b_score", ":", "b_score", "=", "p3", "b_po", "=", "0x0B", "b_is_bigger_side", "=", "False", "elif", "a_score", ">", "b_score", "and", "p3", "<", "a_score", ":", "a_score", "=", "p3", "a_po", "=", "0x0B", "a_is_bigger_side", "=", "False", "# Decide if (1,1,1,0) is closer.", "p4", "=", "3", "-", "in_sum", "+", "wins", "if", "a_score", "<=", "b_score", "and", "p4", "<", "b_score", ":", "b_po", "=", "0x07", "b_is_bigger_side", "=", "False", "elif", "a_score", ">", "b_score", "and", "p4", "<", "a_score", ":", "a_po", "=", "0x07", "a_is_bigger_side", "=", "False", "# Where each of the two closest pos are determines how the extra three vertices are calculated.", "if", "a_is_bigger_side", "==", "b_is_bigger_side", ":", "if", "a_is_bigger_side", ":", "# Both closest pos on the bigger side", "c1", "=", "(", "a_po", "&", "b_po", ")", "c2", "=", "(", "a_po", "|", "b_po", ")", "# Two contributions are _permutations of (0,0,0,1) and (0,0,0,2) based on c1", "xsv_ext0", "=", "xsv_ext1", "=", "xsb", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "wsv_ext0", "=", "wsv_ext1", "=", "wsb", "dx_ext0", "=", "dx0", "-", "SQUISH_CONSTANT_4D", "dy_ext0", "=", "dy0", "-", "SQUISH_CONSTANT_4D", "dz_ext0", "=", "dz0", "-", "SQUISH_CONSTANT_4D", "dw_ext0", "=", "dw0", "-", "SQUISH_CONSTANT_4D", "dx_ext1", "=", "dx0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy_ext1", "=", "dy0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz_ext1", "=", "dz0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw_ext1", "=", "dw0", "-", "2", "*", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x01", ")", "!=", "0", ":", "xsv_ext0", "+=", "1", "dx_ext0", "-=", "1", "xsv_ext1", "+=", "2", "dx_ext1", "-=", "2", "elif", "(", "c1", "&", "0x02", ")", "!=", "0", ":", "ysv_ext0", "+=", "1", "dy_ext0", "-=", "1", "ysv_ext1", "+=", "2", "dy_ext1", "-=", "2", "elif", "(", "c1", "&", "0x04", ")", "!=", "0", ":", "zsv_ext0", "+=", "1", "dz_ext0", "-=", "1", "zsv_ext1", "+=", "2", "dz_ext1", "-=", "2", "else", ":", "wsv_ext0", "+=", "1", "dw_ext0", "-=", "1", "wsv_ext1", "+=", "2", "dw_ext1", "-=", "2", "# One contribution is a _permutation of (1,1,1,-1) based on c2", "xsv_ext2", "=", "xsb", "+", "1", "ysv_ext2", "=", "ysb", "+", "1", "zsv_ext2", "=", "zsb", "+", "1", "wsv_ext2", "=", "wsb", "+", "1", "dx_ext2", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy_ext2", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz_ext2", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw_ext2", "=", "dw0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "if", "(", "c2", "&", "0x01", ")", "==", "0", ":", "xsv_ext2", "-=", "2", "dx_ext2", "+=", "2", "elif", "(", "c2", "&", "0x02", ")", "==", "0", ":", "ysv_ext2", "-=", "2", "dy_ext2", "+=", "2", "elif", "(", "c2", "&", "0x04", ")", "==", "0", ":", "zsv_ext2", "-=", "2", "dz_ext2", "+=", "2", "else", ":", "wsv_ext2", "-=", "2", "dw_ext2", "+=", "2", "else", ":", "# Both closest pos on the smaller side", "# One of the two extra pos is (1,1,1,1)", "xsv_ext2", "=", "xsb", "+", "1", "ysv_ext2", "=", "ysb", "+", "1", "zsv_ext2", "=", "zsb", "+", "1", "wsv_ext2", "=", "wsb", "+", "1", "dx_ext2", "=", "dx0", "-", "1", "-", "4", "*", "SQUISH_CONSTANT_4D", "dy_ext2", "=", "dy0", "-", "1", "-", "4", "*", "SQUISH_CONSTANT_4D", "dz_ext2", "=", "dz0", "-", "1", "-", "4", "*", "SQUISH_CONSTANT_4D", "dw_ext2", "=", "dw0", "-", "1", "-", "4", "*", "SQUISH_CONSTANT_4D", "# Other two pos are based on the shared axes.", "c", "=", "(", "a_po", "&", "b_po", ")", "if", "(", "c", "&", "0x01", ")", "!=", "0", ":", "xsv_ext0", "=", "xsb", "+", "2", "xsv_ext1", "=", "xsb", "+", "1", "dx_ext0", "=", "dx0", "-", "2", "-", "3", "*", "SQUISH_CONSTANT_4D", "dx_ext1", "=", "dx0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsb", "dx_ext0", "=", "dx_ext1", "=", "dx0", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x02", ")", "!=", "0", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "+", "1", "dy_ext0", "=", "dy_ext1", "=", "dy0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x01", ")", "==", "0", ":", "ysv_ext0", "+=", "1", "dy_ext0", "-=", "1", "else", ":", "ysv_ext1", "+=", "1", "dy_ext1", "-=", "1", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "dy_ext0", "=", "dy_ext1", "=", "dy0", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x04", ")", "!=", "0", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "+", "1", "dz_ext0", "=", "dz_ext1", "=", "dz0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x03", ")", "==", "0", ":", "zsv_ext0", "+=", "1", "dz_ext0", "-=", "1", "else", ":", "zsv_ext1", "+=", "1", "dz_ext1", "-=", "1", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "dz_ext0", "=", "dz_ext1", "=", "dz0", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c", "&", "0x08", ")", "!=", "0", ":", "wsv_ext0", "=", "wsb", "+", "1", "wsv_ext1", "=", "wsb", "+", "2", "dw_ext0", "=", "dw0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dw_ext1", "=", "dw0", "-", "2", "-", "3", "*", "SQUISH_CONSTANT_4D", "else", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsb", "dw_ext0", "=", "dw_ext1", "=", "dw0", "-", "3", "*", "SQUISH_CONSTANT_4D", "else", ":", "# One po on each \"side\"", "if", "a_is_bigger_side", ":", "c1", "=", "a_po", "c2", "=", "b_po", "else", ":", "c1", "=", "b_po", "c2", "=", "a_po", "# Two contributions are the bigger-sided po with each 1 replaced with 2.", "if", "(", "c1", "&", "0x01", ")", "!=", "0", ":", "xsv_ext0", "=", "xsb", "+", "2", "xsv_ext1", "=", "xsb", "+", "1", "dx_ext0", "=", "dx0", "-", "2", "-", "3", "*", "SQUISH_CONSTANT_4D", "dx_ext1", "=", "dx0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "else", ":", "xsv_ext0", "=", "xsv_ext1", "=", "xsb", "dx_ext0", "=", "dx_ext1", "=", "dx0", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x02", ")", "!=", "0", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "+", "1", "dy_ext0", "=", "dy_ext1", "=", "dy0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x01", ")", "==", "0", ":", "ysv_ext0", "+=", "1", "dy_ext0", "-=", "1", "else", ":", "ysv_ext1", "+=", "1", "dy_ext1", "-=", "1", "else", ":", "ysv_ext0", "=", "ysv_ext1", "=", "ysb", "dy_ext0", "=", "dy_ext1", "=", "dy0", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x04", ")", "!=", "0", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "+", "1", "dz_ext0", "=", "dz_ext1", "=", "dz0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x03", ")", "==", "0", ":", "zsv_ext0", "+=", "1", "dz_ext0", "-=", "1", "else", ":", "zsv_ext1", "+=", "1", "dz_ext1", "-=", "1", "else", ":", "zsv_ext0", "=", "zsv_ext1", "=", "zsb", "dz_ext0", "=", "dz_ext1", "=", "dz0", "-", "3", "*", "SQUISH_CONSTANT_4D", "if", "(", "c1", "&", "0x08", ")", "!=", "0", ":", "wsv_ext0", "=", "wsb", "+", "1", "wsv_ext1", "=", "wsb", "+", "2", "dw_ext0", "=", "dw0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dw_ext1", "=", "dw0", "-", "2", "-", "3", "*", "SQUISH_CONSTANT_4D", "else", ":", "wsv_ext0", "=", "wsv_ext1", "=", "wsb", "dw_ext0", "=", "dw_ext1", "=", "dw0", "-", "3", "*", "SQUISH_CONSTANT_4D", "# One contribution is a _permutation of (1,1,1,-1) based on the smaller-sided po", "xsv_ext2", "=", "xsb", "+", "1", "ysv_ext2", "=", "ysb", "+", "1", "zsv_ext2", "=", "zsb", "+", "1", "wsv_ext2", "=", "wsb", "+", "1", "dx_ext2", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy_ext2", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz_ext2", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw_ext2", "=", "dw0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "if", "(", "c2", "&", "0x01", ")", "==", "0", ":", "xsv_ext2", "-=", "2", "dx_ext2", "+=", "2", "elif", "(", "c2", "&", "0x02", ")", "==", "0", ":", "ysv_ext2", "-=", "2", "dy_ext2", "+=", "2", "elif", "(", "c2", "&", "0x04", ")", "==", "0", ":", "zsv_ext2", "-=", "2", "dz_ext2", "+=", "2", "else", ":", "wsv_ext2", "-=", "2", "dw_ext2", "+=", "2", "# Contribution (1,1,1,0)", "dx4", "=", "dx0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dy4", "=", "dy0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dz4", "=", "dz0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "dw4", "=", "dw0", "-", "3", "*", "SQUISH_CONSTANT_4D", "attn4", "=", "2", "-", "dx4", "*", "dx4", "-", "dy4", "*", "dy4", "-", "dz4", "*", "dz4", "-", "dw4", "*", "dw4", "if", "attn4", ">", "0", ":", "attn4", "*=", "attn4", "value", "+=", "attn4", "*", "attn4", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "1", ",", "zsb", "+", "1", ",", "wsb", "+", "0", ",", "dx4", ",", "dy4", ",", "dz4", ",", "dw4", ")", "# Contribution (1,1,0,1)", "dx3", "=", "dx4", "dy3", "=", "dy4", "dz3", "=", "dz0", "-", "3", "*", "SQUISH_CONSTANT_4D", "dw3", "=", "dw0", "-", "1", "-", "3", "*", "SQUISH_CONSTANT_4D", "attn3", "=", "2", "-", "dx3", "*", "dx3", "-", "dy3", "*", "dy3", "-", "dz3", "*", "dz3", "-", "dw3", "*", "dw3", "if", "attn3", ">", "0", ":", "attn3", "*=", "attn3", "value", "+=", "attn3", "*", "attn3", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "1", ",", "zsb", "+", "0", ",", "wsb", "+", "1", ",", "dx3", ",", "dy3", ",", "dz3", ",", "dw3", ")", "# Contribution (1,0,1,1)", "dx2", "=", "dx4", "dy2", "=", "dy0", "-", "3", "*", "SQUISH_CONSTANT_4D", "dz2", "=", "dz4", "dw2", "=", "dw3", "attn2", "=", "2", "-", "dx2", "*", "dx2", "-", "dy2", "*", "dy2", "-", "dz2", "*", "dz2", "-", "dw2", "*", "dw2", "if", "attn2", ">", "0", ":", "attn2", "*=", "attn2", "value", "+=", "attn2", "*", "attn2", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "zsb", "+", "1", ",", "wsb", "+", "1", ",", "dx2", ",", "dy2", ",", "dz2", ",", "dw2", ")", "# Contribution (0,1,1,1)", "dx1", "=", "dx0", "-", "3", "*", "SQUISH_CONSTANT_4D", "dz1", "=", "dz4", "dy1", "=", "dy4", "dw1", "=", "dw3", "attn1", "=", "2", "-", "dx1", "*", "dx1", "-", "dy1", "*", "dy1", "-", "dz1", "*", "dz1", "-", "dw1", "*", "dw1", "if", "attn1", ">", "0", ":", "attn1", "*=", "attn1", "value", "+=", "attn1", "*", "attn1", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "zsb", "+", "1", ",", "wsb", "+", "1", ",", "dx1", ",", "dy1", ",", "dz1", ",", "dw1", ")", "# Contribution (1,1,0,0)", "dx5", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy5", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz5", "=", "dz0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw5", "=", "dw0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "attn5", "=", "2", "-", "dx5", "*", "dx5", "-", "dy5", "*", "dy5", "-", "dz5", "*", "dz5", "-", "dw5", "*", "dw5", "if", "attn5", ">", "0", ":", "attn5", "*=", "attn5", "value", "+=", "attn5", "*", "attn5", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "1", ",", "zsb", "+", "0", ",", "wsb", "+", "0", ",", "dx5", ",", "dy5", ",", "dz5", ",", "dw5", ")", "# Contribution (1,0,1,0)", "dx6", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy6", "=", "dy0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz6", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw6", "=", "dw0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "attn6", "=", "2", "-", "dx6", "*", "dx6", "-", "dy6", "*", "dy6", "-", "dz6", "*", "dz6", "-", "dw6", "*", "dw6", "if", "attn6", ">", "0", ":", "attn6", "*=", "attn6", "value", "+=", "attn6", "*", "attn6", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "zsb", "+", "1", ",", "wsb", "+", "0", ",", "dx6", ",", "dy6", ",", "dz6", ",", "dw6", ")", "# Contribution (1,0,0,1)", "dx7", "=", "dx0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy7", "=", "dy0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz7", "=", "dz0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw7", "=", "dw0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "attn7", "=", "2", "-", "dx7", "*", "dx7", "-", "dy7", "*", "dy7", "-", "dz7", "*", "dz7", "-", "dw7", "*", "dw7", "if", "attn7", ">", "0", ":", "attn7", "*=", "attn7", "value", "+=", "attn7", "*", "attn7", "*", "extrapolate", "(", "xsb", "+", "1", ",", "ysb", "+", "0", ",", "zsb", "+", "0", ",", "wsb", "+", "1", ",", "dx7", ",", "dy7", ",", "dz7", ",", "dw7", ")", "# Contribution (0,1,1,0)", "dx8", "=", "dx0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy8", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz8", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw8", "=", "dw0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "attn8", "=", "2", "-", "dx8", "*", "dx8", "-", "dy8", "*", "dy8", "-", "dz8", "*", "dz8", "-", "dw8", "*", "dw8", "if", "attn8", ">", "0", ":", "attn8", "*=", "attn8", "value", "+=", "attn8", "*", "attn8", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "zsb", "+", "1", ",", "wsb", "+", "0", ",", "dx8", ",", "dy8", ",", "dz8", ",", "dw8", ")", "# Contribution (0,1,0,1)", "dx9", "=", "dx0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy9", "=", "dy0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz9", "=", "dz0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw9", "=", "dw0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "attn9", "=", "2", "-", "dx9", "*", "dx9", "-", "dy9", "*", "dy9", "-", "dz9", "*", "dz9", "-", "dw9", "*", "dw9", "if", "attn9", ">", "0", ":", "attn9", "*=", "attn9", "value", "+=", "attn9", "*", "attn9", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "1", ",", "zsb", "+", "0", ",", "wsb", "+", "1", ",", "dx9", ",", "dy9", ",", "dz9", ",", "dw9", ")", "# Contribution (0,0,1,1)", "dx10", "=", "dx0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dy10", "=", "dy0", "-", "0", "-", "2", "*", "SQUISH_CONSTANT_4D", "dz10", "=", "dz0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "dw10", "=", "dw0", "-", "1", "-", "2", "*", "SQUISH_CONSTANT_4D", "attn10", "=", "2", "-", "dx10", "*", "dx10", "-", "dy10", "*", "dy10", "-", "dz10", "*", "dz10", "-", "dw10", "*", "dw10", "if", "attn10", ">", "0", ":", "attn10", "*=", "attn10", "value", "+=", "attn10", "*", "attn10", "*", "extrapolate", "(", "xsb", "+", "0", ",", "ysb", "+", "0", ",", "zsb", "+", "1", ",", "wsb", "+", "1", ",", "dx10", ",", "dy10", ",", "dz10", ",", "dw10", ")", "# First extra vertex", "attn_ext0", "=", "2", "-", "dx_ext0", "*", "dx_ext0", "-", "dy_ext0", "*", "dy_ext0", "-", "dz_ext0", "*", "dz_ext0", "-", "dw_ext0", "*", "dw_ext0", "if", "attn_ext0", ">", "0", ":", "attn_ext0", "*=", "attn_ext0", "value", "+=", "attn_ext0", "*", "attn_ext0", "*", "extrapolate", "(", "xsv_ext0", ",", "ysv_ext0", ",", "zsv_ext0", ",", "wsv_ext0", ",", "dx_ext0", ",", "dy_ext0", ",", "dz_ext0", ",", "dw_ext0", ")", "# Second extra vertex", "attn_ext1", "=", "2", "-", "dx_ext1", "*", "dx_ext1", "-", "dy_ext1", "*", "dy_ext1", "-", "dz_ext1", "*", "dz_ext1", "-", "dw_ext1", "*", "dw_ext1", "if", "attn_ext1", ">", "0", ":", "attn_ext1", "*=", "attn_ext1", "value", "+=", "attn_ext1", "*", "attn_ext1", "*", "extrapolate", "(", "xsv_ext1", ",", "ysv_ext1", ",", "zsv_ext1", ",", "wsv_ext1", ",", "dx_ext1", ",", "dy_ext1", ",", "dz_ext1", ",", "dw_ext1", ")", "# Third extra vertex", "attn_ext2", "=", "2", "-", "dx_ext2", "*", "dx_ext2", "-", "dy_ext2", "*", "dy_ext2", "-", "dz_ext2", "*", "dz_ext2", "-", "dw_ext2", "*", "dw_ext2", "if", "attn_ext2", ">", "0", ":", "attn_ext2", "*=", "attn_ext2", "value", "+=", "attn_ext2", "*", "attn_ext2", "*", "extrapolate", "(", "xsv_ext2", ",", "ysv_ext2", ",", "zsv_ext2", ",", "wsv_ext2", ",", "dx_ext2", ",", "dy_ext2", ",", "dz_ext2", ",", "dw_ext2", ")", "return", "value", "/", "NORM_CONSTANT_4D" ]

[ "Generate", "4D", "OpenSimplex", "noise", "from", "X", "Y", "Z", "W", "coordinates", "." ]

[ "def", "adjust_contrast_gamma", "(", "arr", ",", "gamma", ")", ":", "# int8 is also possible according to docs", "# https://docs.opencv.org/3.0-beta/modules/core/doc/operations_on_arrays.html#cv2.LUT , but here it seemed", "# like `d` was 0 for CV_8S, causing that to fail", "if", "arr", ".", "dtype", ".", "name", "==", "\"uint8\"", ":", "min_value", ",", "_center_value", ",", "max_value", "=", "iadt", ".", "get_value_range_of_dtype", "(", "arr", ".", "dtype", ")", "dynamic_range", "=", "max_value", "-", "min_value", "value_range", "=", "np", ".", "linspace", "(", "0", ",", "1.0", ",", "num", "=", "dynamic_range", "+", "1", ",", "dtype", "=", "np", ".", "float32", ")", "# 255 * ((I_ij/255)**gamma)", "# using np.float32(.) here still works when the input is a numpy array of size 1", "table", "=", "(", "min_value", "+", "(", "value_range", "**", "np", ".", "float32", "(", "gamma", ")", ")", "*", "dynamic_range", ")", "arr_aug", "=", "cv2", ".", "LUT", "(", "arr", ",", "np", ".", "clip", "(", "table", ",", "min_value", ",", "max_value", ")", ".", "astype", "(", "arr", ".", "dtype", ")", ")", "if", "arr", ".", "ndim", "==", "3", "and", "arr_aug", ".", "ndim", "==", "2", ":", "return", "arr_aug", "[", "...", ",", "np", ".", "newaxis", "]", "return", "arr_aug", "else", ":", "return", "ski_exposure", ".", "adjust_gamma", "(", "arr", ",", "gamma", ")" ]

[ "Adjust", "contrast", "by", "scaling", "each", "pixel", "value", "to", "255", "*", "((", "I_ij", "/", "255", ")", "**", "gamma", ")", "." ]

[ "def", "adjust_contrast_sigmoid", "(", "arr", ",", "gain", ",", "cutoff", ")", ":", "# int8 is also possible according to docs", "# https://docs.opencv.org/3.0-beta/modules/core/doc/operations_on_arrays.html#cv2.LUT , but here it seemed", "# like `d` was 0 for CV_8S, causing that to fail", "if", "arr", ".", "dtype", ".", "name", "==", "\"uint8\"", ":", "min_value", ",", "_center_value", ",", "max_value", "=", "iadt", ".", "get_value_range_of_dtype", "(", "arr", ".", "dtype", ")", "dynamic_range", "=", "max_value", "-", "min_value", "value_range", "=", "np", ".", "linspace", "(", "0", ",", "1.0", ",", "num", "=", "dynamic_range", "+", "1", ",", "dtype", "=", "np", ".", "float32", ")", "# 255 * 1/(1 + exp(gain*(cutoff - I_ij/255)))", "# using np.float32(.) here still works when the input is a numpy array of size 1", "gain", "=", "np", ".", "float32", "(", "gain", ")", "cutoff", "=", "np", ".", "float32", "(", "cutoff", ")", "table", "=", "min_value", "+", "dynamic_range", "*", "1", "/", "(", "1", "+", "np", ".", "exp", "(", "gain", "*", "(", "cutoff", "-", "value_range", ")", ")", ")", "arr_aug", "=", "cv2", ".", "LUT", "(", "arr", ",", "np", ".", "clip", "(", "table", ",", "min_value", ",", "max_value", ")", ".", "astype", "(", "arr", ".", "dtype", ")", ")", "if", "arr", ".", "ndim", "==", "3", "and", "arr_aug", ".", "ndim", "==", "2", ":", "return", "arr_aug", "[", "...", ",", "np", ".", "newaxis", "]", "return", "arr_aug", "else", ":", "return", "ski_exposure", ".", "adjust_sigmoid", "(", "arr", ",", "cutoff", "=", "cutoff", ",", "gain", "=", "gain", ")" ]

[ "Adjust", "contrast", "by", "scaling", "each", "pixel", "value", "to", "255", "*", "1", "/", "(", "1", "+", "exp", "(", "gain", "*", "(", "cutoff", "-", "I_ij", "/", "255", ")))", "." ]

[ "def", "adjust_contrast_log", "(", "arr", ",", "gain", ")", ":", "# int8 is also possible according to docs", "# https://docs.opencv.org/3.0-beta/modules/core/doc/operations_on_arrays.html#cv2.LUT , but here it seemed", "# like `d` was 0 for CV_8S, causing that to fail", "if", "arr", ".", "dtype", ".", "name", "==", "\"uint8\"", ":", "min_value", ",", "_center_value", ",", "max_value", "=", "iadt", ".", "get_value_range_of_dtype", "(", "arr", ".", "dtype", ")", "dynamic_range", "=", "max_value", "-", "min_value", "value_range", "=", "np", ".", "linspace", "(", "0", ",", "1.0", ",", "num", "=", "dynamic_range", "+", "1", ",", "dtype", "=", "np", ".", "float32", ")", "# 255 * 1/(1 + exp(gain*(cutoff - I_ij/255)))", "# using np.float32(.) here still works when the input is a numpy array of size 1", "gain", "=", "np", ".", "float32", "(", "gain", ")", "table", "=", "min_value", "+", "dynamic_range", "*", "gain", "*", "np", ".", "log2", "(", "1", "+", "value_range", ")", "arr_aug", "=", "cv2", ".", "LUT", "(", "arr", ",", "np", ".", "clip", "(", "table", ",", "min_value", ",", "max_value", ")", ".", "astype", "(", "arr", ".", "dtype", ")", ")", "if", "arr", ".", "ndim", "==", "3", "and", "arr_aug", ".", "ndim", "==", "2", ":", "return", "arr_aug", "[", "...", ",", "np", ".", "newaxis", "]", "return", "arr_aug", "else", ":", "return", "ski_exposure", ".", "adjust_log", "(", "arr", ",", "gain", "=", "gain", ")" ]

[ "Adjust", "contrast", "by", "scaling", "each", "pixel", "value", "to", "255", "*", "gain", "*", "log_2", "(", "1", "+", "I_ij", "/", "255", ")", "." ]

[ "def", "adjust_contrast_linear", "(", "arr", ",", "alpha", ")", ":", "# int8 is also possible according to docs", "# https://docs.opencv.org/3.0-beta/modules/core/doc/operations_on_arrays.html#cv2.LUT , but here it seemed", "# like `d` was 0 for CV_8S, causing that to fail", "if", "arr", ".", "dtype", ".", "name", "==", "\"uint8\"", ":", "min_value", ",", "center_value", ",", "max_value", "=", "iadt", ".", "get_value_range_of_dtype", "(", "arr", ".", "dtype", ")", "value_range", "=", "np", ".", "arange", "(", "0", ",", "256", ",", "dtype", "=", "np", ".", "float32", ")", "# 127 + alpha*(I_ij-127)", "# using np.float32(.) here still works when the input is a numpy array of size 1", "alpha", "=", "np", ".", "float32", "(", "alpha", ")", "table", "=", "center_value", "+", "alpha", "*", "(", "value_range", "-", "center_value", ")", "arr_aug", "=", "cv2", ".", "LUT", "(", "arr", ",", "np", ".", "clip", "(", "table", ",", "min_value", ",", "max_value", ")", ".", "astype", "(", "arr", ".", "dtype", ")", ")", "if", "arr", ".", "ndim", "==", "3", "and", "arr_aug", ".", "ndim", "==", "2", ":", "return", "arr_aug", "[", "...", ",", "np", ".", "newaxis", "]", "return", "arr_aug", "else", ":", "input_dtype", "=", "arr", ".", "dtype", "_min_value", ",", "center_value", ",", "_max_value", "=", "iadt", ".", "get_value_range_of_dtype", "(", "input_dtype", ")", "if", "input_dtype", ".", "kind", "in", "[", "\"u\"", ",", "\"i\"", "]", ":", "center_value", "=", "int", "(", "center_value", ")", "image_aug", "=", "center_value", "+", "alpha", "*", "(", "arr", ".", "astype", "(", "np", ".", "float64", ")", "-", "center_value", ")", "image_aug", "=", "iadt", ".", "restore_dtypes_", "(", "image_aug", ",", "input_dtype", ")", "return", "image_aug" ]

[ "Adjust", "contrast", "by", "scaling", "each", "pixel", "value", "to", "127", "+", "alpha", "*", "(", "I_ij", "-", "127", ")", "." ]

[ "def", "GammaContrast", "(", "gamma", "=", "1", ",", "per_channel", "=", "False", ",", "name", "=", "None", ",", "deterministic", "=", "False", ",", "random_state", "=", "None", ")", ":", "params1d", "=", "[", "iap", ".", "handle_continuous_param", "(", "gamma", ",", "\"gamma\"", ",", "value_range", "=", "None", ",", "tuple_to_uniform", "=", "True", ",", "list_to_choice", "=", "True", ")", "]", "func", "=", "adjust_contrast_gamma", "return", "_ContrastFuncWrapper", "(", "func", ",", "params1d", ",", "per_channel", ",", "dtypes_allowed", "=", "[", "\"uint8\"", ",", "\"uint16\"", ",", "\"uint32\"", ",", "\"uint64\"", ",", "\"int8\"", ",", "\"int16\"", ",", "\"int32\"", ",", "\"int64\"", ",", "\"float16\"", ",", "\"float32\"", ",", "\"float64\"", "]", ",", "dtypes_disallowed", "=", "[", "\"float96\"", ",", "\"float128\"", ",", "\"float256\"", ",", "\"bool\"", "]", ",", "name", "=", "name", "if", "name", "is", "not", "None", "else", "ia", ".", "caller_name", "(", ")", ",", "deterministic", "=", "deterministic", ",", "random_state", "=", "random_state", ")" ]

[ "Adjust", "contrast", "by", "scaling", "each", "pixel", "value", "to", "255", "*", "((", "I_ij", "/", "255", ")", "**", "gamma", ")", "." ]

[ "def", "SigmoidContrast", "(", "gain", "=", "10", ",", "cutoff", "=", "0.5", ",", "per_channel", "=", "False", ",", "name", "=", "None", ",", "deterministic", "=", "False", ",", "random_state", "=", "None", ")", ":", "# TODO add inv parameter?", "params1d", "=", "[", "iap", ".", "handle_continuous_param", "(", "gain", ",", "\"gain\"", ",", "value_range", "=", "(", "0", ",", "None", ")", ",", "tuple_to_uniform", "=", "True", ",", "list_to_choice", "=", "True", ")", ",", "iap", ".", "handle_continuous_param", "(", "cutoff", ",", "\"cutoff\"", ",", "value_range", "=", "(", "0", ",", "1.0", ")", ",", "tuple_to_uniform", "=", "True", ",", "list_to_choice", "=", "True", ")", "]", "func", "=", "adjust_contrast_sigmoid", "return", "_ContrastFuncWrapper", "(", "func", ",", "params1d", ",", "per_channel", ",", "dtypes_allowed", "=", "[", "\"uint8\"", ",", "\"uint16\"", ",", "\"uint32\"", ",", "\"uint64\"", ",", "\"int8\"", ",", "\"int16\"", ",", "\"int32\"", ",", "\"int64\"", ",", "\"float16\"", ",", "\"float32\"", ",", "\"float64\"", "]", ",", "dtypes_disallowed", "=", "[", "\"float96\"", ",", "\"float128\"", ",", "\"float256\"", ",", "\"bool\"", "]", ",", "name", "=", "name", "if", "name", "is", "not", "None", "else", "ia", ".", "caller_name", "(", ")", ",", "deterministic", "=", "deterministic", ",", "random_state", "=", "random_state", ")" ]

[ "Adjust", "contrast", "by", "scaling", "each", "pixel", "value", "to", "255", "*", "1", "/", "(", "1", "+", "exp", "(", "gain", "*", "(", "cutoff", "-", "I_ij", "/", "255", ")))", "." ]

[ "def", "LogContrast", "(", "gain", "=", "1", ",", "per_channel", "=", "False", ",", "name", "=", "None", ",", "deterministic", "=", "False", ",", "random_state", "=", "None", ")", ":", "# TODO add inv parameter?", "params1d", "=", "[", "iap", ".", "handle_continuous_param", "(", "gain", ",", "\"gain\"", ",", "value_range", "=", "(", "0", ",", "None", ")", ",", "tuple_to_uniform", "=", "True", ",", "list_to_choice", "=", "True", ")", "]", "func", "=", "adjust_contrast_log", "return", "_ContrastFuncWrapper", "(", "func", ",", "params1d", ",", "per_channel", ",", "dtypes_allowed", "=", "[", "\"uint8\"", ",", "\"uint16\"", ",", "\"uint32\"", ",", "\"uint64\"", ",", "\"int8\"", ",", "\"int16\"", ",", "\"int32\"", ",", "\"int64\"", ",", "\"float16\"", ",", "\"float32\"", ",", "\"float64\"", "]", ",", "dtypes_disallowed", "=", "[", "\"float96\"", ",", "\"float128\"", ",", "\"float256\"", ",", "\"bool\"", "]", ",", "name", "=", "name", "if", "name", "is", "not", "None", "else", "ia", ".", "caller_name", "(", ")", ",", "deterministic", "=", "deterministic", ",", "random_state", "=", "random_state", ")" ]

[ "Adjust", "contrast", "by", "scaling", "each", "pixel", "value", "to", "255", "*", "gain", "*", "log_2", "(", "1", "+", "I_ij", "/", "255", ")", "." ]

[ "def", "LinearContrast", "(", "alpha", "=", "1", ",", "per_channel", "=", "False", ",", "name", "=", "None", ",", "deterministic", "=", "False", ",", "random_state", "=", "None", ")", ":", "params1d", "=", "[", "iap", ".", "handle_continuous_param", "(", "alpha", ",", "\"alpha\"", ",", "value_range", "=", "None", ",", "tuple_to_uniform", "=", "True", ",", "list_to_choice", "=", "True", ")", "]", "func", "=", "adjust_contrast_linear", "return", "_ContrastFuncWrapper", "(", "func", ",", "params1d", ",", "per_channel", ",", "dtypes_allowed", "=", "[", "\"uint8\"", ",", "\"uint16\"", ",", "\"uint32\"", ",", "\"int8\"", ",", "\"int16\"", ",", "\"int32\"", ",", "\"float16\"", ",", "\"float32\"", ",", "\"float64\"", "]", ",", "dtypes_disallowed", "=", "[", "\"uint64\"", ",", "\"int64\"", ",", "\"float96\"", ",", "\"float128\"", ",", "\"float256\"", ",", "\"bool\"", "]", ",", "name", "=", "name", "if", "name", "is", "not", "None", "else", "ia", ".", "caller_name", "(", ")", ",", "deterministic", "=", "deterministic", ",", "random_state", "=", "random_state", ")" ]

[ "Adjust", "contrast", "by", "scaling", "each", "pixel", "value", "to", "127", "+", "alpha", "*", "(", "I_ij", "-", "127", ")", "." ]

[ "def", "InColorspace", "(", "to_colorspace", ",", "from_colorspace", "=", "\"RGB\"", ",", "children", "=", "None", ",", "name", "=", "None", ",", "deterministic", "=", "False", ",", "random_state", "=", "None", ")", ":", "return", "WithColorspace", "(", "to_colorspace", ",", "from_colorspace", ",", "children", ",", "name", ",", "deterministic", ",", "random_state", ")" ]

[ "Convert", "images", "to", "another", "colorspace", "." ]

[ "def", "Grayscale", "(", "alpha", "=", "0", ",", "from_colorspace", "=", "\"RGB\"", ",", "name", "=", "None", ",", "deterministic", "=", "False", ",", "random_state", "=", "None", ")", ":", "if", "name", "is", "None", ":", "name", "=", "\"Unnamed%s\"", "%", "(", "ia", ".", "caller_name", "(", ")", ",", ")", "return", "ChangeColorspace", "(", "to_colorspace", "=", "ChangeColorspace", ".", "GRAY", ",", "alpha", "=", "alpha", ",", "from_colorspace", "=", "from_colorspace", ",", "name", "=", "name", ",", "deterministic", "=", "deterministic", ",", "random_state", "=", "random_state", ")" ]

[ "Augmenter", "to", "convert", "images", "to", "their", "grayscale", "versions", "." ]

[ "def", "height", "(", "self", ")", ":", "if", "len", "(", "self", ".", "coords", ")", "<=", "1", ":", "return", "0", "return", "np", ".", "max", "(", "self", ".", "yy", ")", "-", "np", ".", "min", "(", "self", ".", "yy", ")" ]

[ "Get", "the", "height", "of", "a", "bounding", "box", "encapsulating", "the", "line", "." ]

[ "def", "width", "(", "self", ")", ":", "if", "len", "(", "self", ".", "coords", ")", "<=", "1", ":", "return", "0", "return", "np", ".", "max", "(", "self", ".", "xx", ")", "-", "np", ".", "min", "(", "self", ".", "xx", ")" ]

[ "Get", "the", "width", "of", "a", "bounding", "box", "encapsulating", "the", "line", "." ]

[ "def", "get_pointwise_inside_image_mask", "(", "self", ",", "image", ")", ":", "if", "len", "(", "self", ".", "coords", ")", "==", "0", ":", "return", "np", ".", "zeros", "(", "(", "0", ",", ")", ",", "dtype", "=", "bool", ")", "shape", "=", "normalize_shape", "(", "image", ")", "height", ",", "width", "=", "shape", "[", "0", ":", "2", "]", "x_within", "=", "np", ".", "logical_and", "(", "0", "<=", "self", ".", "xx", ",", "self", ".", "xx", "<", "width", ")", "y_within", "=", "np", ".", "logical_and", "(", "0", "<=", "self", ".", "yy", ",", "self", ".", "yy", "<", "height", ")", "return", "np", ".", "logical_and", "(", "x_within", ",", "y_within", ")" ]

[ "Get", "for", "each", "point", "whether", "it", "is", "inside", "of", "the", "given", "image", "plane", "." ]

[ "def", "compute_neighbour_distances", "(", "self", ")", ":", "if", "len", "(", "self", ".", "coords", ")", "<=", "1", ":", "return", "np", ".", "zeros", "(", "(", "0", ",", ")", ",", "dtype", "=", "np", ".", "float32", ")", "return", "np", ".", "sqrt", "(", "np", ".", "sum", "(", "(", "self", ".", "coords", "[", ":", "-", "1", ",", ":", "]", "-", "self", ".", "coords", "[", "1", ":", ",", ":", "]", ")", "**", "2", ",", "axis", "=", "1", ")", ")" ]

[ "Get", "the", "euclidean", "distance", "between", "each", "two", "consecutive", "points", "." ]

[ "def", "compute_pointwise_distances", "(", "self", ",", "other", ",", "default", "=", "None", ")", ":", "import", "shapely", ".", "geometry", "from", ".", "kps", "import", "Keypoint", "if", "isinstance", "(", "other", ",", "Keypoint", ")", ":", "other", "=", "shapely", ".", "geometry", ".", "Point", "(", "(", "other", ".", "x", ",", "other", ".", "y", ")", ")", "elif", "isinstance", "(", "other", ",", "LineString", ")", ":", "if", "len", "(", "other", ".", "coords", ")", "==", "0", ":", "return", "default", "elif", "len", "(", "other", ".", "coords", ")", "==", "1", ":", "other", "=", "shapely", ".", "geometry", ".", "Point", "(", "other", ".", "coords", "[", "0", ",", ":", "]", ")", "else", ":", "other", "=", "shapely", ".", "geometry", ".", "LineString", "(", "other", ".", "coords", ")", "elif", "isinstance", "(", "other", ",", "tuple", ")", ":", "assert", "len", "(", "other", ")", "==", "2", "other", "=", "shapely", ".", "geometry", ".", "Point", "(", "other", ")", "else", ":", "raise", "ValueError", "(", "(", "\"Expected Keypoint or LineString or tuple (x,y), \"", "+", "\"got type %s.\"", ")", "%", "(", "type", "(", "other", ")", ",", ")", ")", "return", "[", "shapely", ".", "geometry", ".", "Point", "(", "point", ")", ".", "distance", "(", "other", ")", "for", "point", "in", "self", ".", "coords", "]" ]

[ "Compute", "the", "minimal", "distance", "between", "each", "point", "on", "self", "and", "other", "." ]

[ "def", "compute_distance", "(", "self", ",", "other", ",", "default", "=", "None", ")", ":", "# FIXME this computes distance pointwise, does not have to be identical", "# with the actual min distance (e.g. edge center to other's point)", "distances", "=", "self", ".", "compute_pointwise_distances", "(", "other", ",", "default", "=", "[", "]", ")", "if", "len", "(", "distances", ")", "==", "0", ":", "return", "default", "return", "min", "(", "distances", ")" ]

[ "Compute", "the", "minimal", "distance", "between", "the", "line", "string", "and", "other", "." ]

[ "def", "contains", "(", "self", ",", "other", ",", "max_distance", "=", "1e-4", ")", ":", "return", "self", ".", "compute_distance", "(", "other", ",", "default", "=", "np", ".", "inf", ")", "<", "max_distance" ]

[ "Estimate", "whether", "the", "bounding", "box", "contains", "a", "point", "." ]

[ "def", "project", "(", "self", ",", "from_shape", ",", "to_shape", ")", ":", "coords_proj", "=", "project_coords", "(", "self", ".", "coords", ",", "from_shape", ",", "to_shape", ")", "return", "self", ".", "copy", "(", "coords", "=", "coords_proj", ")" ]

[ "Project", "the", "line", "string", "onto", "a", "differently", "shaped", "image", "." ]

[ "def", "is_fully_within_image", "(", "self", ",", "image", ",", "default", "=", "False", ")", ":", "if", "len", "(", "self", ".", "coords", ")", "==", "0", ":", "return", "default", "return", "np", ".", "all", "(", "self", ".", "get_pointwise_inside_image_mask", "(", "image", ")", ")" ]

[ "Estimate", "whether", "the", "line", "string", "is", "fully", "inside", "the", "image", "area", "." ]

[ "def", "is_partly_within_image", "(", "self", ",", "image", ",", "default", "=", "False", ")", ":", "if", "len", "(", "self", ".", "coords", ")", "==", "0", ":", "return", "default", "# check mask first to avoid costly computation of intersection points", "# whenever possible", "mask", "=", "self", ".", "get_pointwise_inside_image_mask", "(", "image", ")", "if", "np", ".", "any", "(", "mask", ")", ":", "return", "True", "return", "len", "(", "self", ".", "clip_out_of_image", "(", "image", ")", ")", ">", "0" ]

[ "Estimate", "whether", "the", "line", "string", "is", "at", "least", "partially", "inside", "the", "image", "." ]

[ "def", "is_out_of_image", "(", "self", ",", "image", ",", "fully", "=", "True", ",", "partly", "=", "False", ",", "default", "=", "True", ")", ":", "if", "len", "(", "self", ".", "coords", ")", "==", "0", ":", "return", "default", "if", "self", ".", "is_fully_within_image", "(", "image", ")", ":", "return", "False", "elif", "self", ".", "is_partly_within_image", "(", "image", ")", ":", "return", "partly", "else", ":", "return", "fully" ]

[ "Estimate", "whether", "the", "line", "is", "partially", "/", "fully", "outside", "of", "the", "image", "area", "." ]

[ "def", "clip_out_of_image", "(", "self", ",", "image", ")", ":", "if", "len", "(", "self", ".", "coords", ")", "==", "0", ":", "return", "[", "]", "inside_image_mask", "=", "self", ".", "get_pointwise_inside_image_mask", "(", "image", ")", "ooi_mask", "=", "~", "inside_image_mask", "if", "len", "(", "self", ".", "coords", ")", "==", "1", ":", "if", "not", "np", ".", "any", "(", "inside_image_mask", ")", ":", "return", "[", "]", "return", "[", "self", ".", "copy", "(", ")", "]", "if", "np", ".", "all", "(", "inside_image_mask", ")", ":", "return", "[", "self", ".", "copy", "(", ")", "]", "# top, right, bottom, left image edges", "# we subtract eps here, because intersection() works inclusively,", "# i.e. not subtracting eps would be equivalent to 0<=x<=C for C being", "# height or width", "# don't set the eps too low, otherwise points at height/width seem", "# to get rounded to height/width by shapely, which can cause problems", "# when first clipping and then calling is_fully_within_image()", "# returning false", "height", ",", "width", "=", "normalize_shape", "(", "image", ")", "[", "0", ":", "2", "]", "eps", "=", "1e-3", "edges", "=", "[", "LineString", "(", "[", "(", "0.0", ",", "0.0", ")", ",", "(", "width", "-", "eps", ",", "0.0", ")", "]", ")", ",", "LineString", "(", "[", "(", "width", "-", "eps", ",", "0.0", ")", ",", "(", "width", "-", "eps", ",", "height", "-", "eps", ")", "]", ")", ",", "LineString", "(", "[", "(", "width", "-", "eps", ",", "height", "-", "eps", ")", ",", "(", "0.0", ",", "height", "-", "eps", ")", "]", ")", ",", "LineString", "(", "[", "(", "0.0", ",", "height", "-", "eps", ")", ",", "(", "0.0", ",", "0.0", ")", "]", ")", "]", "intersections", "=", "self", ".", "find_intersections_with", "(", "edges", ")", "points", "=", "[", "]", "gen", "=", "enumerate", "(", "zip", "(", "self", ".", "coords", "[", ":", "-", "1", "]", ",", "self", ".", "coords", "[", "1", ":", "]", ",", "ooi_mask", "[", ":", "-", "1", "]", ",", "ooi_mask", "[", "1", ":", "]", ",", "intersections", ")", ")", "for", "i", ",", "(", "line_start", ",", "line_end", ",", "ooi_start", ",", "ooi_end", ",", "inter_line", ")", "in", "gen", ":", "points", ".", "append", "(", "(", "line_start", ",", "False", ",", "ooi_start", ")", ")", "for", "p_inter", "in", "inter_line", ":", "points", ".", "append", "(", "(", "p_inter", ",", "True", ",", "False", ")", ")", "is_last", "=", "(", "i", "==", "len", "(", "self", ".", "coords", ")", "-", "2", ")", "if", "is_last", "and", "not", "ooi_end", ":", "points", ".", "append", "(", "(", "line_end", ",", "False", ",", "ooi_end", ")", ")", "lines", "=", "[", "]", "line", "=", "[", "]", "for", "i", ",", "(", "coord", ",", "was_added", ",", "ooi", ")", "in", "enumerate", "(", "points", ")", ":", "# remove any point that is outside of the image,", "# also start a new line once such a point is detected", "if", "ooi", ":", "if", "len", "(", "line", ")", ">", "0", ":", "lines", ".", "append", "(", "line", ")", "line", "=", "[", "]", "continue", "if", "not", "was_added", ":", "# add all points that were part of the original line string", "# AND that are inside the image plane", "line", ".", "append", "(", "coord", ")", "else", ":", "is_last_point", "=", "(", "i", "==", "len", "(", "points", ")", "-", "1", ")", "# ooi is a numpy.bool_, hence the bool(.)", "is_next_ooi", "=", "(", "not", "is_last_point", "and", "bool", "(", "points", "[", "i", "+", "1", "]", "[", "2", "]", ")", "is", "True", ")", "# Add all points that were new (i.e. intersections), so", "# long that they aren't essentially identical to other point.", "# This prevents adding overlapping intersections multiple times.", "# (E.g. when a line intersects with a corner of the image plane", "# and also with one of its edges.)", "p_prev", "=", "line", "[", "-", "1", "]", "if", "len", "(", "line", ")", ">", "0", "else", "None", "# ignore next point if end reached or next point is out of image", "p_next", "=", "None", "if", "not", "is_last_point", "and", "not", "is_next_ooi", ":", "p_next", "=", "points", "[", "i", "+", "1", "]", "[", "0", "]", "dist_prev", "=", "None", "dist_next", "=", "None", "if", "p_prev", "is", "not", "None", ":", "dist_prev", "=", "np", ".", "linalg", ".", "norm", "(", "np", ".", "float32", "(", "coord", ")", "-", "np", ".", "float32", "(", "p_prev", ")", ")", "if", "p_next", "is", "not", "None", ":", "dist_next", "=", "np", ".", "linalg", ".", "norm", "(", "np", ".", "float32", "(", "coord", ")", "-", "np", ".", "float32", "(", "p_next", ")", ")", "dist_prev_ok", "=", "(", "dist_prev", "is", "None", "or", "dist_prev", ">", "1e-2", ")", "dist_next_ok", "=", "(", "dist_next", "is", "None", "or", "dist_next", ">", "1e-2", ")", "if", "dist_prev_ok", "and", "dist_next_ok", ":", "line", ".", "append", "(", "coord", ")", "if", "len", "(", "line", ")", ">", "0", ":", "lines", ".", "append", "(", "line", ")", "lines", "=", "[", "line", "for", "line", "in", "lines", "if", "len", "(", "line", ")", ">", "0", "]", "return", "[", "self", ".", "deepcopy", "(", "coords", "=", "line", ")", "for", "line", "in", "lines", "]" ]

[ "Clip", "off", "all", "parts", "of", "the", "line_string", "that", "are", "outside", "of", "the", "image", "." ]

[ "def", "find_intersections_with", "(", "self", ",", "other", ")", ":", "import", "shapely", ".", "geometry", "geom", "=", "_convert_var_to_shapely_geometry", "(", "other", ")", "result", "=", "[", "]", "for", "p_start", ",", "p_end", "in", "zip", "(", "self", ".", "coords", "[", ":", "-", "1", "]", ",", "self", ".", "coords", "[", "1", ":", "]", ")", ":", "ls", "=", "shapely", ".", "geometry", ".", "LineString", "(", "[", "p_start", ",", "p_end", "]", ")", "intersections", "=", "ls", ".", "intersection", "(", "geom", ")", "intersections", "=", "list", "(", "_flatten_shapely_collection", "(", "intersections", ")", ")", "intersections_points", "=", "[", "]", "for", "inter", "in", "intersections", ":", "if", "isinstance", "(", "inter", ",", "shapely", ".", "geometry", ".", "linestring", ".", "LineString", ")", ":", "inter_start", "=", "(", "inter", ".", "coords", "[", "0", "]", "[", "0", "]", ",", "inter", ".", "coords", "[", "0", "]", "[", "1", "]", ")", "inter_end", "=", "(", "inter", ".", "coords", "[", "-", "1", "]", "[", "0", "]", ",", "inter", ".", "coords", "[", "-", "1", "]", "[", "1", "]", ")", "intersections_points", ".", "extend", "(", "[", "inter_start", ",", "inter_end", "]", ")", "else", ":", "assert", "isinstance", "(", "inter", ",", "shapely", ".", "geometry", ".", "point", ".", "Point", ")", ",", "(", "\"Expected to find shapely.geometry.point.Point or \"", "\"shapely.geometry.linestring.LineString intersection, \"", "\"actually found %s.\"", "%", "(", "type", "(", "inter", ")", ",", ")", ")", "intersections_points", ".", "append", "(", "(", "inter", ".", "x", ",", "inter", ".", "y", ")", ")", "# sort by distance to start point, this makes it later on easier", "# to remove duplicate points", "inter_sorted", "=", "sorted", "(", "intersections_points", ",", "key", "=", "lambda", "p", ":", "np", ".", "linalg", ".", "norm", "(", "np", ".", "float32", "(", "p", ")", "-", "p_start", ")", ")", "result", ".", "append", "(", "inter_sorted", ")", "return", "result" ]

[ "Find", "all", "intersection", "points", "between", "the", "line", "string", "and", "other", "." ]

[ "def", "shift", "(", "self", ",", "top", "=", "None", ",", "right", "=", "None", ",", "bottom", "=", "None", ",", "left", "=", "None", ")", ":", "top", "=", "top", "if", "top", "is", "not", "None", "else", "0", "right", "=", "right", "if", "right", "is", "not", "None", "else", "0", "bottom", "=", "bottom", "if", "bottom", "is", "not", "None", "else", "0", "left", "=", "left", "if", "left", "is", "not", "None", "else", "0", "coords", "=", "np", ".", "copy", "(", "self", ".", "coords", ")", "coords", "[", ":", ",", "0", "]", "+=", "left", "-", "right", "coords", "[", ":", ",", "1", "]", "+=", "top", "-", "bottom", "return", "self", ".", "copy", "(", "coords", "=", "coords", ")" ]

[ "Shift", "/", "move", "the", "line", "string", "from", "one", "or", "more", "image", "sides", "." ]

[ "def", "draw_mask", "(", "self", ",", "image_shape", ",", "size_lines", "=", "1", ",", "size_points", "=", "0", ",", "raise_if_out_of_image", "=", "False", ")", ":", "heatmap", "=", "self", ".", "draw_heatmap_array", "(", "image_shape", ",", "alpha_lines", "=", "1.0", ",", "alpha_points", "=", "1.0", ",", "size_lines", "=", "size_lines", ",", "size_points", "=", "size_points", ",", "antialiased", "=", "False", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", "return", "heatmap", ">", "0.5" ]

[ "Draw", "this", "line", "segment", "as", "a", "binary", "image", "mask", "." ]

[ "def", "draw_lines_heatmap_array", "(", "self", ",", "image_shape", ",", "alpha", "=", "1.0", ",", "size", "=", "1", ",", "antialiased", "=", "True", ",", "raise_if_out_of_image", "=", "False", ")", ":", "assert", "len", "(", "image_shape", ")", "==", "2", "or", "(", "len", "(", "image_shape", ")", "==", "3", "and", "image_shape", "[", "-", "1", "]", "==", "1", ")", ",", "(", "\"Expected (H,W) or (H,W,1) as image_shape, got %s.\"", "%", "(", "image_shape", ",", ")", ")", "arr", "=", "self", ".", "draw_lines_on_image", "(", "np", ".", "zeros", "(", "image_shape", ",", "dtype", "=", "np", ".", "uint8", ")", ",", "color", "=", "255", ",", "alpha", "=", "alpha", ",", "size", "=", "size", ",", "antialiased", "=", "antialiased", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", "return", "arr", ".", "astype", "(", "np", ".", "float32", ")", "/", "255.0" ]

[ "Draw", "the", "line", "segments", "of", "the", "line", "string", "as", "a", "heatmap", "array", "." ]

[ "def", "draw_points_heatmap_array", "(", "self", ",", "image_shape", ",", "alpha", "=", "1.0", ",", "size", "=", "1", ",", "raise_if_out_of_image", "=", "False", ")", ":", "assert", "len", "(", "image_shape", ")", "==", "2", "or", "(", "len", "(", "image_shape", ")", "==", "3", "and", "image_shape", "[", "-", "1", "]", "==", "1", ")", ",", "(", "\"Expected (H,W) or (H,W,1) as image_shape, got %s.\"", "%", "(", "image_shape", ",", ")", ")", "arr", "=", "self", ".", "draw_points_on_image", "(", "np", ".", "zeros", "(", "image_shape", ",", "dtype", "=", "np", ".", "uint8", ")", ",", "color", "=", "255", ",", "alpha", "=", "alpha", ",", "size", "=", "size", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", "return", "arr", ".", "astype", "(", "np", ".", "float32", ")", "/", "255.0" ]

[ "Draw", "the", "points", "of", "the", "line", "string", "as", "a", "heatmap", "array", "." ]

[ "def", "draw_heatmap_array", "(", "self", ",", "image_shape", ",", "alpha_lines", "=", "1.0", ",", "alpha_points", "=", "1.0", ",", "size_lines", "=", "1", ",", "size_points", "=", "0", ",", "antialiased", "=", "True", ",", "raise_if_out_of_image", "=", "False", ")", ":", "heatmap_lines", "=", "self", ".", "draw_lines_heatmap_array", "(", "image_shape", ",", "alpha", "=", "alpha_lines", ",", "size", "=", "size_lines", ",", "antialiased", "=", "antialiased", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", "if", "size_points", "<=", "0", ":", "return", "heatmap_lines", "heatmap_points", "=", "self", ".", "draw_points_heatmap_array", "(", "image_shape", ",", "alpha", "=", "alpha_points", ",", "size", "=", "size_points", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", "heatmap", "=", "np", ".", "dstack", "(", "[", "heatmap_lines", ",", "heatmap_points", "]", ")", "return", "np", ".", "max", "(", "heatmap", ",", "axis", "=", "2", ")" ]

[ "Draw", "the", "line", "segments", "and", "points", "of", "the", "line", "string", "as", "a", "heatmap", "array", "." ]

[ "def", "draw_lines_on_image", "(", "self", ",", "image", ",", "color", "=", "(", "0", ",", "255", ",", "0", ")", ",", "alpha", "=", "1.0", ",", "size", "=", "3", ",", "antialiased", "=", "True", ",", "raise_if_out_of_image", "=", "False", ")", ":", "from", ".", ".", "import", "dtypes", "as", "iadt", "from", ".", ".", "augmenters", "import", "blend", "as", "blendlib", "image_was_empty", "=", "False", "if", "isinstance", "(", "image", ",", "tuple", ")", ":", "image_was_empty", "=", "True", "image", "=", "np", ".", "zeros", "(", "image", ",", "dtype", "=", "np", ".", "uint8", ")", "assert", "image", ".", "ndim", "in", "[", "2", ",", "3", "]", ",", "(", "(", "\"Expected image or shape of form (H,W) or (H,W,C), \"", "+", "\"got shape %s.\"", ")", "%", "(", "image", ".", "shape", ",", ")", ")", "if", "len", "(", "self", ".", "coords", ")", "<=", "1", "or", "alpha", "<", "0", "+", "1e-4", "or", "size", "<", "1", ":", "return", "np", ".", "copy", "(", "image", ")", "if", "raise_if_out_of_image", "and", "self", ".", "is_out_of_image", "(", "image", ",", "partly", "=", "False", ",", "fully", "=", "True", ")", ":", "raise", "Exception", "(", "\"Cannot draw line string '%s' on image with shape %s, because \"", "\"it would be out of bounds.\"", "%", "(", "self", ".", "__str__", "(", ")", ",", "image", ".", "shape", ")", ")", "if", "image", ".", "ndim", "==", "2", ":", "assert", "ia", ".", "is_single_number", "(", "color", ")", ",", "(", "\"Got a 2D image. Expected then 'color' to be a single number, \"", "\"but got %s.\"", "%", "(", "str", "(", "color", ")", ",", ")", ")", "color", "=", "[", "color", "]", "elif", "image", ".", "ndim", "==", "3", "and", "ia", ".", "is_single_number", "(", "color", ")", ":", "color", "=", "[", "color", "]", "*", "image", ".", "shape", "[", "-", "1", "]", "image", "=", "image", ".", "astype", "(", "np", ".", "float32", ")", "height", ",", "width", "=", "image", ".", "shape", "[", "0", ":", "2", "]", "# We can't trivially exclude lines outside of the image here, because", "# even if start and end point are outside, there can still be parts of", "# the line inside the image.", "# TODO Do this with edge-wise intersection tests", "lines", "=", "[", "]", "for", "line_start", ",", "line_end", "in", "zip", "(", "self", ".", "coords", "[", ":", "-", "1", "]", ",", "self", ".", "coords", "[", "1", ":", "]", ")", ":", "# note that line() expects order (y1, x1, y2, x2), hence ([1], [0])", "lines", ".", "append", "(", "(", "line_start", "[", "1", "]", ",", "line_start", "[", "0", "]", ",", "line_end", "[", "1", "]", ",", "line_end", "[", "0", "]", ")", ")", "# skimage.draw.line can only handle integers", "lines", "=", "np", ".", "round", "(", "np", ".", "float32", "(", "lines", ")", ")", ".", "astype", "(", "np", ".", "int32", ")", "# size == 0 is already covered above", "# Note here that we have to be careful not to draw lines two times", "# at their intersection points, e.g. for (p0, p1), (p1, 2) we could", "# end up drawing at p1 twice, leading to higher values if alpha is used.", "color", "=", "np", ".", "float32", "(", "color", ")", "heatmap", "=", "np", ".", "zeros", "(", "image", ".", "shape", "[", "0", ":", "2", "]", ",", "dtype", "=", "np", ".", "float32", ")", "for", "line", "in", "lines", ":", "if", "antialiased", ":", "rr", ",", "cc", ",", "val", "=", "skimage", ".", "draw", ".", "line_aa", "(", "*", "line", ")", "else", ":", "rr", ",", "cc", "=", "skimage", ".", "draw", ".", "line", "(", "*", "line", ")", "val", "=", "1.0", "# mask check here, because line() can generate coordinates", "# outside of the image plane", "rr_mask", "=", "np", ".", "logical_and", "(", "0", "<=", "rr", ",", "rr", "<", "height", ")", "cc_mask", "=", "np", ".", "logical_and", "(", "0", "<=", "cc", ",", "cc", "<", "width", ")", "mask", "=", "np", ".", "logical_and", "(", "rr_mask", ",", "cc_mask", ")", "if", "np", ".", "any", "(", "mask", ")", ":", "rr", "=", "rr", "[", "mask", "]", "cc", "=", "cc", "[", "mask", "]", "val", "=", "val", "[", "mask", "]", "if", "not", "ia", ".", "is_single_number", "(", "val", ")", "else", "val", "heatmap", "[", "rr", ",", "cc", "]", "=", "val", "*", "alpha", "if", "size", ">", "1", ":", "kernel", "=", "np", ".", "ones", "(", "(", "size", ",", "size", ")", ",", "dtype", "=", "np", ".", "uint8", ")", "heatmap", "=", "cv2", ".", "dilate", "(", "heatmap", ",", "kernel", ")", "if", "image_was_empty", ":", "image_blend", "=", "image", "+", "heatmap", "*", "color", "else", ":", "image_color_shape", "=", "image", ".", "shape", "[", "0", ":", "2", "]", "if", "image", ".", "ndim", "==", "3", ":", "image_color_shape", "=", "image_color_shape", "+", "(", "1", ",", ")", "image_color", "=", "np", ".", "tile", "(", "color", ",", "image_color_shape", ")", "image_blend", "=", "blendlib", ".", "blend_alpha", "(", "image_color", ",", "image", ",", "heatmap", ")", "image_blend", "=", "iadt", ".", "restore_dtypes_", "(", "image_blend", ",", "np", ".", "uint8", ")", "return", "image_blend" ]

[ "Draw", "the", "line", "segments", "of", "the", "line", "string", "on", "a", "given", "image", "." ]

[ "def", "draw_points_on_image", "(", "self", ",", "image", ",", "color", "=", "(", "0", ",", "128", ",", "0", ")", ",", "alpha", "=", "1.0", ",", "size", "=", "3", ",", "copy", "=", "True", ",", "raise_if_out_of_image", "=", "False", ")", ":", "from", ".", "kps", "import", "KeypointsOnImage", "kpsoi", "=", "KeypointsOnImage", ".", "from_xy_array", "(", "self", ".", "coords", ",", "shape", "=", "image", ".", "shape", ")", "image", "=", "kpsoi", ".", "draw_on_image", "(", "image", ",", "color", "=", "color", ",", "alpha", "=", "alpha", ",", "size", "=", "size", ",", "copy", "=", "copy", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", "return", "image" ]

[ "Draw", "the", "points", "of", "the", "line", "string", "on", "a", "given", "image", "." ]

[ "def", "draw_on_image", "(", "self", ",", "image", ",", "color", "=", "(", "0", ",", "255", ",", "0", ")", ",", "color_lines", "=", "None", ",", "color_points", "=", "None", ",", "alpha", "=", "1.0", ",", "alpha_lines", "=", "None", ",", "alpha_points", "=", "None", ",", "size", "=", "1", ",", "size_lines", "=", "None", ",", "size_points", "=", "None", ",", "antialiased", "=", "True", ",", "raise_if_out_of_image", "=", "False", ")", ":", "assert", "color", "is", "not", "None", "assert", "alpha", "is", "not", "None", "assert", "size", "is", "not", "None", "color_lines", "=", "color_lines", "if", "color_lines", "is", "not", "None", "else", "np", ".", "float32", "(", "color", ")", "color_points", "=", "color_points", "if", "color_points", "is", "not", "None", "else", "np", ".", "float32", "(", "color", ")", "*", "0.5", "alpha_lines", "=", "alpha_lines", "if", "alpha_lines", "is", "not", "None", "else", "np", ".", "float32", "(", "alpha", ")", "alpha_points", "=", "alpha_points", "if", "alpha_points", "is", "not", "None", "else", "np", ".", "float32", "(", "alpha", ")", "size_lines", "=", "size_lines", "if", "size_lines", "is", "not", "None", "else", "size", "size_points", "=", "size_points", "if", "size_points", "is", "not", "None", "else", "size", "*", "3", "image", "=", "self", ".", "draw_lines_on_image", "(", "image", ",", "color", "=", "np", ".", "array", "(", "color_lines", ")", ".", "astype", "(", "np", ".", "uint8", ")", ",", "alpha", "=", "alpha_lines", ",", "size", "=", "size_lines", ",", "antialiased", "=", "antialiased", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", "image", "=", "self", ".", "draw_points_on_image", "(", "image", ",", "color", "=", "np", ".", "array", "(", "color_points", ")", ".", "astype", "(", "np", ".", "uint8", ")", ",", "alpha", "=", "alpha_points", ",", "size", "=", "size_points", ",", "copy", "=", "False", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", "return", "image" ]

[ "Draw", "the", "line", "string", "on", "an", "image", "." ]

[ "def", "extract_from_image", "(", "self", ",", "image", ",", "size", "=", "1", ",", "pad", "=", "True", ",", "pad_max", "=", "None", ",", "antialiased", "=", "True", ",", "prevent_zero_size", "=", "True", ")", ":", "from", ".", "bbs", "import", "BoundingBox", "assert", "image", ".", "ndim", "in", "[", "2", ",", "3", "]", ",", "(", "\"Expected image of shape (H,W,[C]), \"", "\"got shape %s.\"", "%", "(", "image", ".", "shape", ",", ")", ")", "if", "len", "(", "self", ".", "coords", ")", "==", "0", "or", "size", "<=", "0", ":", "if", "prevent_zero_size", ":", "return", "np", ".", "zeros", "(", "(", "1", ",", "1", ")", "+", "image", ".", "shape", "[", "2", ":", "]", ",", "dtype", "=", "image", ".", "dtype", ")", "return", "np", ".", "zeros", "(", "(", "0", ",", "0", ")", "+", "image", ".", "shape", "[", "2", ":", "]", ",", "dtype", "=", "image", ".", "dtype", ")", "xx", "=", "self", ".", "xx_int", "yy", "=", "self", ".", "yy_int", "# this would probably work if drawing was subpixel-accurate", "# x1 = np.min(self.coords[:, 0]) - (size / 2)", "# y1 = np.min(self.coords[:, 1]) - (size / 2)", "# x2 = np.max(self.coords[:, 0]) + (size / 2)", "# y2 = np.max(self.coords[:, 1]) + (size / 2)", "# this works currently with non-subpixel-accurate drawing", "sizeh", "=", "(", "size", "-", "1", ")", "/", "2", "x1", "=", "np", ".", "min", "(", "xx", ")", "-", "sizeh", "y1", "=", "np", ".", "min", "(", "yy", ")", "-", "sizeh", "x2", "=", "np", ".", "max", "(", "xx", ")", "+", "1", "+", "sizeh", "y2", "=", "np", ".", "max", "(", "yy", ")", "+", "1", "+", "sizeh", "bb", "=", "BoundingBox", "(", "x1", "=", "x1", ",", "y1", "=", "y1", ",", "x2", "=", "x2", ",", "y2", "=", "y2", ")", "if", "len", "(", "self", ".", "coords", ")", "==", "1", ":", "return", "bb", ".", "extract_from_image", "(", "image", ",", "pad", "=", "pad", ",", "pad_max", "=", "pad_max", ",", "prevent_zero_size", "=", "prevent_zero_size", ")", "heatmap", "=", "self", ".", "draw_lines_heatmap_array", "(", "image", ".", "shape", "[", "0", ":", "2", "]", ",", "alpha", "=", "1.0", ",", "size", "=", "size", ",", "antialiased", "=", "antialiased", ")", "if", "image", ".", "ndim", "==", "3", ":", "heatmap", "=", "np", ".", "atleast_3d", "(", "heatmap", ")", "image_masked", "=", "image", ".", "astype", "(", "np", ".", "float32", ")", "*", "heatmap", "extract", "=", "bb", ".", "extract_from_image", "(", "image_masked", ",", "pad", "=", "pad", ",", "pad_max", "=", "pad_max", ",", "prevent_zero_size", "=", "prevent_zero_size", ")", "return", "np", ".", "clip", "(", "np", ".", "round", "(", "extract", ")", ",", "0", ",", "255", ")", ".", "astype", "(", "np", ".", "uint8", ")" ]

[ "Extract", "the", "image", "pixels", "covered", "by", "the", "line", "string", "." ]

[ "def", "concatenate", "(", "self", ",", "other", ")", ":", "if", "not", "isinstance", "(", "other", ",", "LineString", ")", ":", "other", "=", "LineString", "(", "other", ")", "return", "self", ".", "deepcopy", "(", "coords", "=", "np", ".", "concatenate", "(", "[", "self", ".", "coords", ",", "other", ".", "coords", "]", ",", "axis", "=", "0", ")", ")" ]

[ "Concatenate", "this", "line", "string", "with", "another", "one", "." ]

[ "def", "subdivide", "(", "self", ",", "points_per_edge", ")", ":", "if", "len", "(", "self", ".", "coords", ")", "<=", "1", "or", "points_per_edge", "<", "1", ":", "return", "self", ".", "deepcopy", "(", ")", "coords", "=", "interpolate_points", "(", "self", ".", "coords", ",", "nb_steps", "=", "points_per_edge", ",", "closed", "=", "False", ")", "return", "self", ".", "deepcopy", "(", "coords", "=", "coords", ")" ]

[ "Adds", "N", "interpolated", "points", "with", "uniform", "spacing", "to", "each", "edge", "." ]

[ "def", "to_keypoints", "(", "self", ")", ":", "# TODO get rid of this deferred import", "from", "imgaug", ".", "augmentables", ".", "kps", "import", "Keypoint", "return", "[", "Keypoint", "(", "x", "=", "x", ",", "y", "=", "y", ")", "for", "(", "x", ",", "y", ")", "in", "self", ".", "coords", "]" ]

[ "Convert", "the", "line", "string", "points", "to", "keypoints", "." ]

[ "def", "to_bounding_box", "(", "self", ")", ":", "from", ".", "bbs", "import", "BoundingBox", "# we don't have to mind the case of len(.) == 1 here, because", "# zero-sized BBs are considered valid", "if", "len", "(", "self", ".", "coords", ")", "==", "0", ":", "return", "None", "return", "BoundingBox", "(", "x1", "=", "np", ".", "min", "(", "self", ".", "xx", ")", ",", "y1", "=", "np", ".", "min", "(", "self", ".", "yy", ")", ",", "x2", "=", "np", ".", "max", "(", "self", ".", "xx", ")", ",", "y2", "=", "np", ".", "max", "(", "self", ".", "yy", ")", ",", "label", "=", "self", ".", "label", ")" ]

[ "Generate", "a", "bounding", "box", "encapsulating", "the", "line", "string", "." ]

[ "def", "to_polygon", "(", "self", ")", ":", "from", ".", "polys", "import", "Polygon", "return", "Polygon", "(", "self", ".", "coords", ",", "label", "=", "self", ".", "label", ")" ]

[ "Generate", "a", "polygon", "from", "the", "line", "string", "points", "." ]

[ "def", "to_heatmap", "(", "self", ",", "image_shape", ",", "size_lines", "=", "1", ",", "size_points", "=", "0", ",", "antialiased", "=", "True", ",", "raise_if_out_of_image", "=", "False", ")", ":", "from", ".", "heatmaps", "import", "HeatmapsOnImage", "return", "HeatmapsOnImage", "(", "self", ".", "draw_heatmap_array", "(", "image_shape", ",", "size_lines", "=", "size_lines", ",", "size_points", "=", "size_points", ",", "antialiased", "=", "antialiased", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", ",", "shape", "=", "image_shape", ")" ]

[ "Generate", "a", "heatmap", "object", "from", "the", "line", "string", "." ]

[ "def", "to_segmentation_map", "(", "self", ",", "image_shape", ",", "size_lines", "=", "1", ",", "size_points", "=", "0", ",", "raise_if_out_of_image", "=", "False", ")", ":", "from", ".", "segmaps", "import", "SegmentationMapOnImage", "return", "SegmentationMapOnImage", "(", "self", ".", "draw_mask", "(", "image_shape", ",", "size_lines", "=", "size_lines", ",", "size_points", "=", "size_points", ",", "raise_if_out_of_image", "=", "raise_if_out_of_image", ")", ",", "shape", "=", "image_shape", ")" ]

[ "Generate", "a", "segmentation", "map", "object", "from", "the", "line", "string", "." ]

[ "def", "coords_almost_equals", "(", "self", ",", "other", ",", "max_distance", "=", "1e-6", ",", "points_per_edge", "=", "8", ")", ":", "if", "isinstance", "(", "other", ",", "LineString", ")", ":", "pass", "elif", "isinstance", "(", "other", ",", "tuple", ")", ":", "other", "=", "LineString", "(", "[", "other", "]", ")", "else", ":", "other", "=", "LineString", "(", "other", ")", "if", "len", "(", "self", ".", "coords", ")", "==", "0", "and", "len", "(", "other", ".", "coords", ")", "==", "0", ":", "return", "True", "elif", "0", "in", "[", "len", "(", "self", ".", "coords", ")", ",", "len", "(", "other", ".", "coords", ")", "]", ":", "# only one of the two line strings has no coords", "return", "False", "self_subd", "=", "self", ".", "subdivide", "(", "points_per_edge", ")", "other_subd", "=", "other", ".", "subdivide", "(", "points_per_edge", ")", "dist_self2other", "=", "self_subd", ".", "compute_pointwise_distances", "(", "other_subd", ")", "dist_other2self", "=", "other_subd", ".", "compute_pointwise_distances", "(", "self_subd", ")", "dist", "=", "max", "(", "np", ".", "max", "(", "dist_self2other", ")", ",", "np", ".", "max", "(", "dist_other2self", ")", ")", "return", "dist", "<", "max_distance" ]

[ "Compare", "this", "and", "another", "LineString", "s", "coordinates", "." ]

[ "def", "almost_equals", "(", "self", ",", "other", ",", "max_distance", "=", "1e-4", ",", "points_per_edge", "=", "8", ")", ":", "if", "self", ".", "label", "!=", "other", ".", "label", ":", "return", "False", "return", "self", ".", "coords_almost_equals", "(", "other", ",", "max_distance", "=", "max_distance", ",", "points_per_edge", "=", "points_per_edge", ")" ]

[ "Compare", "this", "and", "another", "LineString", "." ]

[ "def", "copy", "(", "self", ",", "coords", "=", "None", ",", "label", "=", "None", ")", ":", "return", "LineString", "(", "coords", "=", "self", ".", "coords", "if", "coords", "is", "None", "else", "coords", ",", "label", "=", "self", ".", "label", "if", "label", "is", "None", "else", "label", ")" ]

[ "Create", "a", "shallow", "copy", "of", "the", "LineString", "object", "." ]

[ "def", "deepcopy", "(", "self", ",", "coords", "=", "None", ",", "label", "=", "None", ")", ":", "return", "LineString", "(", "coords", "=", "np", ".", "copy", "(", "self", ".", "coords", ")", "if", "coords", "is", "None", "else", "coords", ",", "label", "=", "copylib", ".", "deepcopy", "(", "self", ".", "label", ")", "if", "label", "is", "None", "else", "label", ")" ]

[ "Create", "a", "deep", "copy", "of", "the", "BoundingBox", "object", "." ]