Datasets:

---

jqop

/

python-code-dataset

like 0

[ "def", "parse_strike_dip", "(", "strike", ",", "dip", ")", ":", "strike", "=", "parse_azimuth", "(", "strike", ")", "dip", ",", "direction", "=", "split_trailing_letters", "(", "dip", ")", "if", "direction", "is", "not", "None", ":", "expected_direc", "=", "strike", "+", "90", "if", "opposite_end", "(", "expected_direc", ",", "direction", ")", ":", "strike", "+=", "180", "if", "strike", ">", "360", ":", "strike", "-=", "360", "return", "strike", ",", "dip" ]

[ "Parses", "strings", "of", "strike", "and", "dip", "and", "returns", "strike", "and", "dip", "measurements", "following", "the", "right", "-", "hand", "-", "rule", "." ]

[ "def", "parse_rake", "(", "strike", ",", "dip", ",", "rake", ")", ":", "strike", ",", "dip", "=", "parse_strike_dip", "(", "strike", ",", "dip", ")", "rake", ",", "direction", "=", "split_trailing_letters", "(", "rake", ")", "if", "direction", "is", "not", "None", ":", "if", "opposite_end", "(", "strike", ",", "direction", ")", ":", "rake", "=", "-", "rake", "if", "rake", "<", "0", ":", "rake", "+=", "180", "elif", "rake", ">", "180", ":", "rake", "-=", "180", "return", "strike", ",", "dip", ",", "rake" ]

[ "Parses", "strings", "of", "strike", "dip", "and", "rake", "and", "returns", "a", "strike", "dip", "and", "rake", "measurement", "following", "the", "right", "-", "hand", "-", "rule", "with", "the", "end", "of", "the", "strike", "that", "the", "rake", "is", "measured", "from", "indicated", "by", "the", "sign", "of", "the", "rake", "(", "positive", "rakes", "correspond", "to", "the", "strike", "direction", "negative", "rakes", "correspond", "to", "the", "opposite", "end", ")", "." ]

[ "def", "parse_plunge_bearing", "(", "plunge", ",", "bearing", ")", ":", "bearing", "=", "parse_azimuth", "(", "bearing", ")", "plunge", ",", "direction", "=", "split_trailing_letters", "(", "plunge", ")", "if", "direction", "is", "not", "None", ":", "if", "opposite_end", "(", "bearing", ",", "direction", ")", ":", "bearing", "+=", "180", "if", "plunge", "<", "0", ":", "bearing", "+=", "180", "plunge", "=", "-", "plunge", "if", "plunge", ">", "90", ":", "bearing", "+=", "180", "plunge", "=", "180", "-", "plunge", "if", "bearing", ">", "360", ":", "bearing", "-=", "360", "return", "plunge", ",", "bearing" ]

[ "Parses", "strings", "of", "plunge", "and", "bearing", "and", "returns", "a", "consistent", "plunge", "and", "bearing", "measurement", "as", "floats", ".", "Plunge", "angles", "returned", "by", "this", "function", "will", "always", "be", "between", "0", "and", "90", "." ]

[ "def", "dip_direction2strike", "(", "azimuth", ")", ":", "azimuth", "=", "parse_azimuth", "(", "azimuth", ")", "strike", "=", "azimuth", "-", "90", "if", "strike", "<", "0", ":", "strike", "+=", "360", "return", "strike" ]

[ "Converts", "a", "planar", "measurment", "of", "dip", "direction", "using", "the", "dip", "-", "azimuth", "convention", "into", "a", "strike", "using", "the", "right", "-", "hand", "-", "rule", "." ]

[ "def", "strike2dip_direction", "(", "strike", ")", ":", "strike", "=", "parse_azimuth", "(", "strike", ")", "dip_direction", "=", "strike", "+", "90", "if", "dip_direction", ">", "360", ":", "dip_direction", "-=", "360", "return", "dip_direction" ]

[ "Converts", "a", "planar", "measurement", "of", "strike", "using", "the", "right", "-", "hand", "-", "rule", "into", "the", "dip", "direction", "(", "i", ".", "e", ".", "the", "direction", "that", "the", "plane", "dips", ")", "." ]

[ "def", "parse_azimuth", "(", "azimuth", ")", ":", "try", ":", "azimuth", "=", "float", "(", "azimuth", ")", "except", "ValueError", ":", "if", "not", "azimuth", "[", "0", "]", ".", "isalpha", "(", ")", ":", "raise", "ValueError", "(", "'Ambiguous azimuth: {}'", ".", "format", "(", "azimuth", ")", ")", "azimuth", "=", "parse_quadrant_measurement", "(", "azimuth", ")", "return", "azimuth" ]

[ "Parses", "an", "azimuth", "measurement", "in", "azimuth", "or", "quadrant", "format", "." ]

[ "def", "parse_quadrant_measurement", "(", "quad_azimuth", ")", ":", "def", "rotation_direction", "(", "first", ",", "second", ")", ":", "return", "np", ".", "cross", "(", "_azimuth2vec", "(", "first", ")", ",", "_azimuth2vec", "(", "second", ")", ")", "# Parse measurement", "quad_azimuth", "=", "quad_azimuth", ".", "strip", "(", ")", "try", ":", "first_dir", "=", "quadrantletter_to_azimuth", "(", "quad_azimuth", "[", "0", "]", ".", "upper", "(", ")", ")", "sec_dir", "=", "quadrantletter_to_azimuth", "(", "quad_azimuth", "[", "-", "1", "]", ".", "upper", "(", ")", ")", "except", "KeyError", ":", "raise", "ValueError", "(", "'{} is not a valid azimuth'", ".", "format", "(", "quad_azimuth", ")", ")", "angle", "=", "float", "(", "quad_azimuth", "[", "1", ":", "-", "1", "]", ")", "# Convert quadrant measurement into an azimuth", "direc", "=", "rotation_direction", "(", "first_dir", ",", "sec_dir", ")", "azi", "=", "first_dir", "+", "direc", "*", "angle", "# Catch ambiguous measurements such as N10S and raise an error", "if", "abs", "(", "direc", ")", "<", "0.9", ":", "raise", "ValueError", "(", "'{} is not a valid azimuth'", ".", "format", "(", "quad_azimuth", ")", ")", "# Ensure that 0 <= azi <= 360", "if", "azi", "<", "0", ":", "azi", "+=", "360", "elif", "azi", ">", "360", ":", "azi", "-=", "360", "return", "azi" ]

[ "Parses", "a", "quadrant", "measurement", "of", "the", "form", "AxxB", "where", "A", "and", "B", "are", "cardinal", "directions", "and", "xx", "is", "an", "angle", "measured", "relative", "to", "those", "directions", "." ]

[ "def", "inverted", "(", "self", ")", ":", "# This is a bit of hackery so that we can put a single \"inverse\"", "# function here. If we just made \"self._inverse_type\" point to the class", "# in question, it wouldn't be defined yet. This way, it's done at", "# at runtime and we avoid the definition problem. Hackish, but better", "# than repeating code everywhere or making a relatively complex", "# metaclass.", "inverse_type", "=", "globals", "(", ")", "[", "self", ".", "_inverse_type", "]", "return", "inverse_type", "(", "self", ".", "_center_longitude", ",", "self", ".", "_center_latitude", ",", "self", ".", "_resolution", ")" ]

[ "Return", "the", "inverse", "of", "the", "transform", "." ]

[ "def", "sph2cart", "(", "lon", ",", "lat", ")", ":", "x", "=", "np", ".", "cos", "(", "lat", ")", "*", "np", ".", "cos", "(", "lon", ")", "y", "=", "np", ".", "cos", "(", "lat", ")", "*", "np", ".", "sin", "(", "lon", ")", "z", "=", "np", ".", "sin", "(", "lat", ")", "return", "x", ",", "y", ",", "z" ]

[ "Converts", "a", "longitude", "and", "latitude", "(", "or", "sequence", "of", "lons", "and", "lats", ")", "given", "in", "_radians_", "to", "cartesian", "coordinates", "x", "y", "z", "where", "x", "=", "0", "y", "=", "0", "z", "=", "0", "is", "the", "center", "of", "the", "globe", "." ]

[ "def", "cart2sph", "(", "x", ",", "y", ",", "z", ")", ":", "r", "=", "np", ".", "sqrt", "(", "x", "**", "2", "+", "y", "**", "2", "+", "z", "**", "2", ")", "lat", "=", "np", ".", "arcsin", "(", "z", "/", "r", ")", "lon", "=", "np", ".", "arctan2", "(", "y", ",", "x", ")", "return", "lon", ",", "lat" ]

[ "Converts", "cartesian", "coordinates", "x", "y", "z", "into", "a", "longitude", "and", "latitude", ".", "x", "=", "0", "y", "=", "0", "z", "=", "0", "is", "assumed", "to", "correspond", "to", "the", "center", "of", "the", "globe", ".", "Returns", "lon", "and", "lat", "in", "radians", "." ]

[ "def", "_rotate", "(", "lon", ",", "lat", ",", "theta", ",", "axis", "=", "'x'", ")", ":", "# Convert input to numpy arrays in radians", "lon", ",", "lat", "=", "np", ".", "atleast_1d", "(", "lon", ",", "lat", ")", "lon", ",", "lat", "=", "map", "(", "np", ".", "radians", ",", "[", "lon", ",", "lat", "]", ")", "theta", "=", "np", ".", "radians", "(", "theta", ")", "# Convert to cartesian coords for the rotation", "x", ",", "y", ",", "z", "=", "sph2cart", "(", "lon", ",", "lat", ")", "lookup", "=", "{", "'x'", ":", "_rotate_x", ",", "'y'", ":", "_rotate_y", ",", "'z'", ":", "_rotate_z", "}", "X", ",", "Y", ",", "Z", "=", "lookup", "[", "axis", "]", "(", "x", ",", "y", ",", "z", ",", "theta", ")", "# Now convert back to spherical coords (longitude and latitude, ignore R)", "lon", ",", "lat", "=", "cart2sph", "(", "X", ",", "Y", ",", "Z", ")", "return", "lon", ",", "lat" ]

[ "Rotate", "lon", "lat", "coords", "(", "in", "_degrees_", ")", "about", "the", "X", "-", "axis", "by", "theta", "degrees", ".", "This", "effectively", "simulates", "rotating", "a", "physical", "stereonet", ".", "Returns", "rotated", "lon", "lat", "coords", "in", "_radians_", ")", "." ]

[ "def", "antipode", "(", "lon", ",", "lat", ")", ":", "x", ",", "y", ",", "z", "=", "sph2cart", "(", "lon", ",", "lat", ")", "return", "cart2sph", "(", "-", "x", ",", "-", "y", ",", "-", "z", ")" ]

[ "Calculates", "the", "antipode", "(", "opposite", "point", "on", "the", "globe", ")", "of", "the", "given", "point", "or", "points", ".", "Input", "and", "output", "is", "expected", "to", "be", "in", "radians", "." ]

[ "def", "plane", "(", "strike", ",", "dip", ",", "segments", "=", "100", ",", "center", "=", "(", "0", ",", "0", ")", ")", ":", "lon0", ",", "lat0", "=", "center", "strikes", ",", "dips", "=", "np", ".", "atleast_1d", "(", "strike", ",", "dip", ")", "lons", "=", "np", ".", "zeros", "(", "(", "segments", ",", "strikes", ".", "size", ")", ",", "dtype", "=", "np", ".", "float", ")", "lats", "=", "lons", ".", "copy", "(", ")", "for", "i", ",", "(", "strike", ",", "dip", ")", "in", "enumerate", "(", "zip", "(", "strikes", ",", "dips", ")", ")", ":", "# We just plot a line of constant longitude and rotate it by the strike.", "dip", "=", "90", "-", "dip", "lon", "=", "dip", "*", "np", ".", "ones", "(", "segments", ")", "lat", "=", "np", ".", "linspace", "(", "-", "90", ",", "90", ",", "segments", ")", "lon", ",", "lat", "=", "_rotate", "(", "lon", ",", "lat", ",", "strike", ")", "if", "lat0", "!=", "0", "or", "lon0", "!=", "0", ":", "dist", "=", "angular_distance", "(", "[", "lon", ",", "lat", "]", ",", "[", "lon0", ",", "lat0", "]", ",", "False", ")", "mask", "=", "dist", ">", "(", "np", ".", "pi", "/", "2", ")", "lon", "[", "mask", "]", ",", "lat", "[", "mask", "]", "=", "antipode", "(", "lon", "[", "mask", "]", ",", "lat", "[", "mask", "]", ")", "change", "=", "np", ".", "diff", "(", "mask", ".", "astype", "(", "int", ")", ")", "ind", "=", "np", ".", "flatnonzero", "(", "change", ")", "+", "1", "lat", "=", "np", ".", "hstack", "(", "np", ".", "split", "(", "lat", ",", "ind", ")", "[", ":", ":", "-", "1", "]", ")", "lon", "=", "np", ".", "hstack", "(", "np", ".", "split", "(", "lon", ",", "ind", ")", "[", ":", ":", "-", "1", "]", ")", "lons", "[", ":", ",", "i", "]", "=", "lon", "lats", "[", ":", ",", "i", "]", "=", "lat", "return", "lons", ",", "lats" ]

[ "Calculates", "the", "longitude", "and", "latitude", "of", "segments", "points", "along", "the", "stereonet", "projection", "of", "each", "plane", "with", "a", "given", "strike", "and", "dip", "in", "degrees", ".", "Returns", "points", "for", "one", "hemisphere", "only", "." ]

[ "def", "pole", "(", "strike", ",", "dip", ")", ":", "strike", ",", "dip", "=", "np", ".", "atleast_1d", "(", "strike", ",", "dip", ")", "mask", "=", "dip", ">", "90", "dip", "[", "mask", "]", "=", "180", "-", "dip", "[", "mask", "]", "strike", "[", "mask", "]", "+=", "180", "# Plot the approriate point for a strike of 0 and rotate it", "lon", ",", "lat", "=", "-", "dip", ",", "0.0", "lon", ",", "lat", "=", "_rotate", "(", "lon", ",", "lat", ",", "strike", ")", "return", "lon", ",", "lat" ]

[ "Calculates", "the", "longitude", "and", "latitude", "of", "the", "pole", "(", "s", ")", "to", "the", "plane", "(", "s", ")", "specified", "by", "strike", "and", "dip", "given", "in", "degrees", "." ]

[ "def", "rake", "(", "strike", ",", "dip", ",", "rake_angle", ")", ":", "strike", ",", "dip", ",", "rake_angle", "=", "np", ".", "atleast_1d", "(", "strike", ",", "dip", ",", "rake_angle", ")", "# Plot the approriate point for a strike of 0 and rotate it", "dip", "=", "90", "-", "dip", "lon", "=", "dip", "rake_angle", "=", "rake_angle", ".", "copy", "(", ")", "rake_angle", "[", "rake_angle", "<", "0", "]", "+=", "180", "lat", "=", "90", "-", "rake_angle", "lon", ",", "lat", "=", "_rotate", "(", "lon", ",", "lat", ",", "strike", ")", "return", "lon", ",", "lat" ]

[ "Calculates", "the", "longitude", "and", "latitude", "of", "the", "linear", "feature", "(", "s", ")", "specified", "by", "strike", "dip", "and", "rake_angle", "." ]

[ "def", "line", "(", "plunge", ",", "bearing", ")", ":", "plunge", ",", "bearing", "=", "np", ".", "atleast_1d", "(", "plunge", ",", "bearing", ")", "# Plot the approriate point for a bearing of 0 and rotate it", "lat", "=", "90", "-", "plunge", "lon", "=", "0", "lon", ",", "lat", "=", "_rotate", "(", "lon", ",", "lat", ",", "bearing", ")", "return", "lon", ",", "lat" ]

[ "Calculates", "the", "longitude", "and", "latitude", "of", "the", "linear", "feature", "(", "s", ")", "specified", "by", "plunge", "and", "bearing", "." ]

[ "def", "cone", "(", "plunge", ",", "bearing", ",", "angle", ",", "segments", "=", "100", ")", ":", "plunges", ",", "bearings", ",", "angles", "=", "np", ".", "atleast_1d", "(", "plunge", ",", "bearing", ",", "angle", ")", "lons", ",", "lats", "=", "[", "]", ",", "[", "]", "for", "plunge", ",", "bearing", ",", "angle", "in", "zip", "(", "plunges", ",", "bearings", ",", "angles", ")", ":", "lat", "=", "(", "90", "-", "angle", ")", "*", "np", ".", "ones", "(", "segments", ",", "dtype", "=", "float", ")", "lon", "=", "np", ".", "linspace", "(", "-", "180", ",", "180", ",", "segments", ")", "lon", ",", "lat", "=", "_rotate", "(", "lon", ",", "lat", ",", "-", "plunge", ",", "axis", "=", "'y'", ")", "lon", ",", "lat", "=", "_rotate", "(", "np", ".", "degrees", "(", "lon", ")", ",", "np", ".", "degrees", "(", "lat", ")", ",", "bearing", ",", "axis", "=", "'x'", ")", "lons", ".", "append", "(", "lon", ")", "lats", ".", "append", "(", "lat", ")", "return", "np", ".", "vstack", "(", "lons", ")", ",", "np", ".", "vstack", "(", "lats", ")" ]

[ "Calculates", "the", "longitude", "and", "latitude", "of", "the", "small", "circle", "(", "i", ".", "e", ".", "a", "cone", ")", "centered", "at", "the", "given", "*", "plunge", "*", "and", "*", "bearing", "*", "with", "an", "apical", "angle", "of", "*", "angle", "*", "all", "in", "degrees", "." ]

[ "def", "plunge_bearing2pole", "(", "plunge", ",", "bearing", ")", ":", "plunge", ",", "bearing", "=", "np", ".", "atleast_1d", "(", "plunge", ",", "bearing", ")", "strike", "=", "bearing", "+", "90", "dip", "=", "90", "-", "plunge", "strike", "[", "strike", ">=", "360", "]", "-=", "360", "return", "strike", ",", "dip" ]

[ "Converts", "the", "given", "plunge", "and", "bearing", "in", "degrees", "to", "a", "strike", "and", "dip", "of", "the", "plane", "whose", "pole", "would", "be", "parallel", "to", "the", "line", "specified", ".", "(", "i", ".", "e", ".", "The", "pole", "to", "the", "plane", "returned", "would", "plot", "at", "the", "same", "point", "as", "the", "specified", "plunge", "and", "bearing", ".", ")" ]

[ "def", "pole2plunge_bearing", "(", "strike", ",", "dip", ")", ":", "strike", ",", "dip", "=", "np", ".", "atleast_1d", "(", "strike", ",", "dip", ")", "bearing", "=", "strike", "-", "90", "plunge", "=", "90", "-", "dip", "bearing", "[", "bearing", "<", "0", "]", "+=", "360", "return", "plunge", ",", "bearing" ]

[ "Converts", "the", "given", "*", "strike", "*", "and", "*", "dip", "*", "in", "dgrees", "of", "a", "plane", "(", "s", ")", "to", "a", "plunge", "and", "bearing", "of", "its", "pole", "." ]

[ "def", "mean_vector", "(", "lons", ",", "lats", ")", ":", "xyz", "=", "sph2cart", "(", "lons", ",", "lats", ")", "xyz", "=", "np", ".", "vstack", "(", "xyz", ")", ".", "T", "mean_vec", "=", "xyz", ".", "mean", "(", "axis", "=", "0", ")", "r_value", "=", "np", ".", "linalg", ".", "norm", "(", "mean_vec", ")", "mean_vec", "=", "cart2sph", "(", "*", "mean_vec", ")", "return", "mean_vec", ",", "r_value" ]

[ "Returns", "the", "resultant", "vector", "from", "a", "series", "of", "longitudes", "and", "latitudes" ]

[ "def", "fisher_stats", "(", "lons", ",", "lats", ",", "conf", "=", "95", ")", ":", "xyz", "=", "sph2cart", "(", "lons", ",", "lats", ")", "xyz", "=", "np", ".", "vstack", "(", "xyz", ")", ".", "T", "mean_vec", "=", "xyz", ".", "mean", "(", "axis", "=", "0", ")", "r_value", "=", "np", ".", "linalg", ".", "norm", "(", "mean_vec", ")", "num", "=", "xyz", ".", "shape", "[", "0", "]", "mean_vec", "=", "cart2sph", "(", "*", "mean_vec", ")", "if", "num", ">", "1", ":", "p", "=", "(", "100.0", "-", "conf", ")", "/", "100.0", "vector_sum", "=", "xyz", ".", "sum", "(", "axis", "=", "0", ")", "result_vect", "=", "np", ".", "sqrt", "(", "np", ".", "sum", "(", "np", ".", "square", "(", "vector_sum", ")", ")", ")", "fract1", "=", "(", "num", "-", "result_vect", ")", "/", "result_vect", "fract3", "=", "1.0", "/", "(", "num", "-", "1.0", ")", "angle", "=", "np", ".", "arccos", "(", "1", "-", "fract1", "*", "(", "(", "1", "/", "p", ")", "**", "fract3", "-", "1", ")", ")", "angle", "=", "np", ".", "degrees", "(", "angle", ")", "kappa", "=", "(", "num", "-", "1.0", ")", "/", "(", "num", "-", "result_vect", ")", "return", "mean_vec", ",", "(", "r_value", ",", "angle", ",", "kappa", ")", "else", ":", "return", "None", ",", "None" ]

[ "Returns", "the", "resultant", "vector", "from", "a", "series", "of", "longitudes", "and", "latitudes", ".", "If", "a", "confidence", "is", "set", "the", "function", "additionally", "returns", "the", "opening", "angle", "of", "the", "confidence", "small", "circle", "(", "Fisher", "19", "..", ")", "and", "the", "dispersion", "factor", "(", "kappa", ")", "." ]

[ "def", "geographic2pole", "(", "lon", ",", "lat", ")", ":", "plunge", ",", "bearing", "=", "geographic2plunge_bearing", "(", "lon", ",", "lat", ")", "strike", "=", "bearing", "+", "90", "strike", "[", "strike", ">=", "360", "]", "-=", "360", "dip", "=", "90", "-", "plunge", "return", "strike", ",", "dip" ]

[ "Converts", "a", "longitude", "and", "latitude", "(", "from", "a", "stereonet", ")", "into", "the", "strike", "and", "dip", "of", "the", "plane", "whose", "pole", "lies", "at", "the", "given", "longitude", "(", "s", ")", "and", "latitude", "(", "s", ")", "." ]

[ "def", "geographic2plunge_bearing", "(", "lon", ",", "lat", ")", ":", "lon", ",", "lat", "=", "np", ".", "atleast_1d", "(", "lon", ",", "lat", ")", "x", ",", "y", ",", "z", "=", "sph2cart", "(", "lon", ",", "lat", ")", "# Bearing will be in the y-z plane...", "bearing", "=", "np", ".", "arctan2", "(", "z", ",", "y", ")", "# Plunge is the angle between the line and the y-z plane", "r", "=", "np", ".", "sqrt", "(", "x", "*", "x", "+", "y", "*", "y", "+", "z", "*", "z", ")", "r", "[", "r", "==", "0", "]", "=", "1e-15", "plunge", "=", "np", ".", "arcsin", "(", "x", "/", "r", ")", "# Convert back to azimuths in degrees..", "plunge", ",", "bearing", "=", "np", ".", "degrees", "(", "plunge", ")", ",", "np", ".", "degrees", "(", "bearing", ")", "bearing", "=", "90", "-", "bearing", "bearing", "[", "bearing", "<", "0", "]", "+=", "360", "# If the plunge angle is upwards, get the opposite end of the line", "upwards", "=", "plunge", "<", "0", "plunge", "[", "upwards", "]", "*=", "-", "1", "bearing", "[", "upwards", "]", "-=", "180", "bearing", "[", "upwards", "&", "(", "bearing", "<", "0", ")", "]", "+=", "360", "return", "plunge", ",", "bearing" ]

[ "Converts", "longitude", "and", "latitude", "in", "stereonet", "coordinates", "into", "a", "plunge", "/", "bearing", "." ]

[ "def", "plane_intersection", "(", "strike1", ",", "dip1", ",", "strike2", ",", "dip2", ")", ":", "norm1", "=", "sph2cart", "(", "*", "pole", "(", "strike1", ",", "dip1", ")", ")", "norm2", "=", "sph2cart", "(", "*", "pole", "(", "strike2", ",", "dip2", ")", ")", "norm1", ",", "norm2", "=", "np", ".", "array", "(", "norm1", ")", ",", "np", ".", "array", "(", "norm2", ")", "lon", ",", "lat", "=", "cart2sph", "(", "*", "np", ".", "cross", "(", "norm1", ",", "norm2", ",", "axis", "=", "0", ")", ")", "return", "geographic2plunge_bearing", "(", "lon", ",", "lat", ")" ]

[ "Finds", "the", "intersection", "of", "two", "planes", ".", "Returns", "a", "plunge", "/", "bearing", "of", "the", "linear", "intersection", "of", "the", "two", "planes", "." ]

[ "def", "project_onto_plane", "(", "strike", ",", "dip", ",", "plunge", ",", "bearing", ")", ":", "# Project the line onto the plane", "norm", "=", "sph2cart", "(", "*", "pole", "(", "strike", ",", "dip", ")", ")", "feature", "=", "sph2cart", "(", "*", "line", "(", "plunge", ",", "bearing", ")", ")", "norm", ",", "feature", "=", "np", ".", "array", "(", "norm", ")", ",", "np", ".", "array", "(", "feature", ")", "perp", "=", "np", ".", "cross", "(", "norm", ",", "feature", ",", "axis", "=", "0", ")", "on_plane", "=", "np", ".", "cross", "(", "perp", ",", "norm", ",", "axis", "=", "0", ")", "on_plane", "/=", "np", ".", "sqrt", "(", "np", ".", "sum", "(", "on_plane", "**", "2", ",", "axis", "=", "0", ")", ")", "# Calculate the angle between the projected feature and horizontal", "# This is just a dot product, but we need to work with multiple measurements", "# at once, so einsum is quicker than apply_along_axis.", "strike_vec", "=", "sph2cart", "(", "*", "line", "(", "0", ",", "strike", ")", ")", "dot", "=", "np", ".", "einsum", "(", "'ij,ij->j'", ",", "on_plane", ",", "strike_vec", ")", "rake", "=", "np", ".", "degrees", "(", "np", ".", "arccos", "(", "dot", ")", ")", "# Convert rakes over 90 to negative rakes...", "rake", "[", "rake", ">", "90", "]", "-=", "180", "rake", "[", "rake", "<", "-", "90", "]", "+=", "180", "return", "rake" ]

[ "Projects", "a", "linear", "feature", "(", "s", ")", "onto", "the", "surface", "of", "a", "plane", ".", "Returns", "a", "rake", "angle", "(", "s", ")", "along", "the", "plane", "." ]

[ "def", "azimuth2rake", "(", "strike", ",", "dip", ",", "azimuth", ")", ":", "plunge", ",", "bearing", "=", "plane_intersection", "(", "strike", ",", "dip", ",", "azimuth", ",", "90", ")", "rake", "=", "project_onto_plane", "(", "strike", ",", "dip", ",", "plunge", ",", "bearing", ")", "return", "rake" ]

[ "Projects", "an", "azimuth", "of", "a", "linear", "feature", "onto", "a", "plane", "as", "a", "rake", "angle", "." ]

[ "def", "xyz2stereonet", "(", "x", ",", "y", ",", "z", ")", ":", "x", ",", "y", ",", "z", "=", "np", ".", "atleast_1d", "(", "x", ",", "y", ",", "z", ")", "return", "cart2sph", "(", "-", "z", ",", "x", ",", "y", ")" ]

[ "Converts", "x", "y", "z", "in", "_world_", "cartesian", "coordinates", "into", "lower", "-", "hemisphere", "stereonet", "coordinates", "." ]

[ "def", "stereonet2xyz", "(", "lon", ",", "lat", ")", ":", "lon", ",", "lat", "=", "np", ".", "atleast_1d", "(", "lon", ",", "lat", ")", "x", ",", "y", ",", "z", "=", "sph2cart", "(", "lon", ",", "lat", ")", "return", "y", ",", "z", ",", "-", "x" ]

[ "Converts", "a", "sequence", "of", "longitudes", "and", "latitudes", "from", "a", "lower", "-", "hemisphere", "stereonet", "into", "_world_", "x", "y", "z", "coordinates", "." ]

[ "def", "angular_distance", "(", "first", ",", "second", ",", "bidirectional", "=", "True", ")", ":", "lon1", ",", "lat1", "=", "first", "lon2", ",", "lat2", "=", "second", "lon1", ",", "lat1", ",", "lon2", ",", "lat2", "=", "np", ".", "atleast_1d", "(", "lon1", ",", "lat1", ",", "lon2", ",", "lat2", ")", "xyz1", "=", "sph2cart", "(", "lon1", ",", "lat1", ")", "xyz2", "=", "sph2cart", "(", "lon2", ",", "lat2", ")", "# This is just a dot product, but we need to work with multiple measurements", "# at once, so einsum is quicker than apply_along_axis.", "dot", "=", "np", ".", "einsum", "(", "'ij,ij->j'", ",", "xyz1", ",", "xyz2", ")", "angle", "=", "np", ".", "arccos", "(", "dot", ")", "# There are numerical sensitivity issues around 180 and 0 degrees...", "# Sometimes a result will have an absolute value slighly over 1.", "if", "np", ".", "any", "(", "np", ".", "isnan", "(", "angle", ")", ")", ":", "rtol", "=", "1e-4", "angle", "[", "np", ".", "isclose", "(", "dot", ",", "-", "1", ",", "rtol", ")", "]", "=", "np", ".", "pi", "angle", "[", "np", ".", "isclose", "(", "dot", ",", "1", ",", "rtol", ")", "]", "=", "0", "if", "bidirectional", ":", "mask", "=", "angle", ">", "np", ".", "pi", "/", "2", "angle", "[", "mask", "]", "=", "np", ".", "pi", "-", "angle", "[", "mask", "]", "return", "angle" ]

[ "Calculate", "the", "angular", "distance", "between", "two", "linear", "features", "or", "elementwise", "angular", "distance", "between", "two", "sets", "of", "linear", "features", ".", "(", "Note", ":", "a", "linear", "feature", "in", "this", "context", "is", "a", "point", "on", "a", "stereonet", "represented", "by", "a", "single", "latitude", "and", "longitude", ".", ")" ]

[ "def", "_repole", "(", "lon", ",", "lat", ",", "center", ")", ":", "vec3", "=", "sph2cart", "(", "*", "center", ")", "vec3", "=", "np", ".", "squeeze", "(", "vec3", ")", "if", "not", "np", ".", "allclose", "(", "vec3", ",", "[", "0", ",", "0", ",", "1", "]", ")", ":", "vec1", "=", "np", ".", "cross", "(", "vec3", ",", "[", "0", ",", "0", ",", "1", "]", ")", "else", ":", "vec1", "=", "np", ".", "cross", "(", "vec3", ",", "[", "1", ",", "0", ",", "0", "]", ")", "vec2", "=", "np", ".", "cross", "(", "vec3", ",", "vec1", ")", "vecs", "=", "[", "item", "/", "np", ".", "linalg", ".", "norm", "(", "item", ")", "for", "item", "in", "[", "vec1", ",", "vec2", ",", "vec3", "]", "]", "basis", "=", "np", ".", "column_stack", "(", "vecs", ")", "xyz", "=", "sph2cart", "(", "lon", ",", "lat", ")", "xyz", "=", "np", ".", "column_stack", "(", "xyz", ")", "prime", "=", "xyz", ".", "dot", "(", "np", ".", "linalg", ".", "inv", "(", "basis", ")", ")", "lon", ",", "lat", "=", "cart2sph", "(", "*", "prime", ".", "T", ")", "return", "lon", "[", ":", ",", "None", "]", ",", "lat", "[", ":", ",", "None", "]" ]

[ "Reproject", "data", "such", "that", "center", "is", "the", "north", "pole", ".", "Returns", "lon", "lat", "in", "the", "new", "rotated", "reference", "frame", "." ]

[ "def", "_sd_of_eigenvector", "(", "data", ",", "vec", ",", "measurement", "=", "'poles'", ",", "bidirectional", "=", "True", ")", ":", "lon", ",", "lat", "=", "_convert_measurements", "(", "data", ",", "measurement", ")", "vals", ",", "vecs", "=", "cov_eig", "(", "lon", ",", "lat", ",", "bidirectional", ")", "x", ",", "y", ",", "z", "=", "vecs", "[", ":", ",", "vec", "]", "s", ",", "d", "=", "stereonet_math", ".", "geographic2pole", "(", "*", "stereonet_math", ".", "cart2sph", "(", "x", ",", "y", ",", "z", ")", ")", "return", "s", "[", "0", "]", ",", "d", "[", "0", "]" ]

[ "Unifies", "fit_pole", "and", "fit_girdle", "." ]

[ "def", "eigenvectors", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "lon", ",", "lat", "=", "_convert_measurements", "(", "args", ",", "kwargs", ".", "get", "(", "'measurement'", ",", "'poles'", ")", ")", "vals", ",", "vecs", "=", "cov_eig", "(", "lon", ",", "lat", ",", "kwargs", ".", "get", "(", "'bidirectional'", ",", "True", ")", ")", "lon", ",", "lat", "=", "stereonet_math", ".", "cart2sph", "(", "*", "vecs", ")", "plunges", ",", "bearings", "=", "stereonet_math", ".", "geographic2plunge_bearing", "(", "lon", ",", "lat", ")", "# Largest eigenvalue first...", "return", "plunges", "[", ":", ":", "-", "1", "]", ",", "bearings", "[", ":", ":", "-", "1", "]", ",", "vals", "[", ":", ":", "-", "1", "]" ]

[ "Finds", "the", "3", "eigenvectors", "and", "eigenvalues", "of", "the", "3D", "covariance", "matrix", "of", "a", "series", "of", "geometries", ".", "This", "can", "be", "used", "to", "fit", "a", "plane", "/", "pole", "to", "a", "dataset", "or", "for", "shape", "fabric", "analysis", "(", "e", ".", "g", ".", "Flinn", "/", "Hsu", "plots", ")", "." ]

[ "def", "find_mean_vector", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "lon", ",", "lat", "=", "_convert_measurements", "(", "args", ",", "kwargs", ".", "get", "(", "'measurement'", ",", "'lines'", ")", ")", "vector", ",", "r_value", "=", "stereonet_math", ".", "mean_vector", "(", "lon", ",", "lat", ")", "plunge", ",", "bearing", "=", "stereonet_math", ".", "geographic2plunge_bearing", "(", "*", "vector", ")", "return", "(", "plunge", "[", "0", "]", ",", "bearing", "[", "0", "]", ")", ",", "r_value" ]

[ "Returns", "the", "mean", "vector", "for", "a", "set", "of", "measurments", ".", "By", "default", "this", "expects", "the", "input", "to", "be", "plunges", "and", "bearings", "but", "the", "type", "of", "input", "can", "be", "controlled", "through", "the", "measurement", "kwarg", "." ]

[ "def", "find_fisher_stats", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "# How the heck did this wind up as a separate function?", "lon", ",", "lat", "=", "_convert_measurements", "(", "args", ",", "kwargs", ".", "get", "(", "'measurement'", ",", "'lines'", ")", ")", "conf", "=", "kwargs", ".", "get", "(", "'conf'", ",", "95", ")", "center", ",", "stats", "=", "stereonet_math", ".", "fisher_stats", "(", "lon", ",", "lat", ",", "conf", ")", "plunge", ",", "bearing", "=", "stereonet_math", ".", "geographic2plunge_bearing", "(", "*", "center", ")", "mean_vector", "=", "(", "plunge", "[", "0", "]", ",", "bearing", "[", "0", "]", ")", "return", "mean_vector", ",", "stats" ]

[ "Returns", "the", "mean", "vector", "and", "summary", "statistics", "for", "a", "set", "of", "measurements", ".", "By", "default", "this", "expects", "the", "input", "to", "be", "plunges", "and", "bearings", "but", "the", "type", "of", "input", "can", "be", "controlled", "through", "the", "measurement", "kwarg", "." ]

[ "def", "kmeans", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "lon", ",", "lat", "=", "_convert_measurements", "(", "args", ",", "kwargs", ".", "get", "(", "'measurement'", ",", "'poles'", ")", ")", "num", "=", "kwargs", ".", "get", "(", "'num'", ",", "2", ")", "bidirectional", "=", "kwargs", ".", "get", "(", "'bidirectional'", ",", "True", ")", "tolerance", "=", "kwargs", ".", "get", "(", "'tolerance'", ",", "1e-5", ")", "points", "=", "lon", ",", "lat", "dist", "=", "lambda", "x", ":", "stereonet_math", ".", "angular_distance", "(", "x", ",", "points", ",", "bidirectional", ")", "center_lon", "=", "np", ".", "random", ".", "choice", "(", "lon", ",", "num", ")", "center_lat", "=", "np", ".", "random", ".", "choice", "(", "lat", ",", "num", ")", "centers", "=", "np", ".", "column_stack", "(", "[", "center_lon", ",", "center_lat", "]", ")", "while", "True", ":", "dists", "=", "np", ".", "array", "(", "[", "dist", "(", "item", ")", "for", "item", "in", "centers", "]", ")", ".", "T", "closest", "=", "dists", ".", "argmin", "(", "axis", "=", "1", ")", "new_centers", "=", "[", "]", "for", "i", "in", "range", "(", "num", ")", ":", "mask", "=", "mask", "=", "closest", "==", "i", "_", ",", "vecs", "=", "cov_eig", "(", "lon", "[", "mask", "]", ",", "lat", "[", "mask", "]", ",", "bidirectional", ")", "new_centers", ".", "append", "(", "stereonet_math", ".", "cart2sph", "(", "*", "vecs", "[", ":", ",", "-", "1", "]", ")", ")", "if", "np", ".", "allclose", "(", "centers", ",", "new_centers", ",", "atol", "=", "tolerance", ")", ":", "break", "else", ":", "centers", "=", "new_centers", "return", "centers" ]

[ "Find", "centers", "of", "multi", "-", "modal", "clusters", "of", "data", "using", "a", "kmeans", "approach", "modified", "for", "spherical", "measurements", "." ]

[ "def", "is_disconnect", "(", "e", ",", "connection", ",", "cursor", ")", ":", "if", "isinstance", "(", "e", ",", "OperationalError", ")", ":", "# these error messages from libpq: interfaces/libpq/fe-misc.c.", "# TODO: these are sent through gettext in libpq and we can't", "# check within other locales - consider using connection.closed", "return", "'terminating connection'", "in", "str", "(", "e", ")", "or", "'closed the connection'", "in", "str", "(", "e", ")", "or", "'connection not open'", "in", "str", "(", "e", ")", "or", "'could not receive data from server'", "in", "str", "(", "e", ")", "elif", "isinstance", "(", "e", ",", "InterfaceError", ")", ":", "# psycopg2 client errors, psycopg2/conenction.h, psycopg2/cursor.h", "return", "'connection already closed'", "in", "str", "(", "e", ")", "or", "'cursor already closed'", "in", "str", "(", "e", ")", "elif", "isinstance", "(", "e", ",", "ProgrammingError", ")", ":", "# not sure where this path is originally from, it may", "# be obsolete. It really says \"losed\", not \"closed\".", "return", "\"closed the connection unexpectedly\"", "in", "str", "(", "e", ")", "else", ":", "return", "False" ]

[ "Connection", "state", "check", "from", "SQLAlchemy", ":", "https", ":", "//", "bitbucket", ".", "org", "/", "sqlalchemy", "/", "sqlalchemy", "/", "src", "/", "tip", "/", "lib", "/", "sqlalchemy", "/", "dialects", "/", "postgresql", "/", "psycopg2", ".", "py" ]

[ "def", "_dispose", "(", "self", ")", ":", "self", ".", "close", "(", ")", "# _DBProxy.dispose doesn't actually call dispose on the pool", "conn_params", "=", "self", ".", "get_connection_params", "(", ")", "key", "=", "db_pool", ".", "_serialize", "(", "*", "*", "conn_params", ")", "try", ":", "pool", "=", "db_pool", ".", "pools", "[", "key", "]", "except", "KeyError", ":", "pass", "else", ":", "pool", ".", "dispose", "(", ")", "del", "db_pool", ".", "pools", "[", "key", "]" ]

[ "Dispose", "of", "the", "pool", "for", "this", "instance", "closing", "all", "connections", "." ]

[ "def", "calc_fc_size", "(", "img_height", ",", "img_width", ")", ":", "height", ",", "width", "=", "img_height", ",", "img_width", "for", "_", "in", "range", "(", "5", ")", ":", "height", ",", "width", "=", "_get_conv_outsize", "(", "(", "height", ",", "width", ")", ",", "4", ",", "2", ",", "1", ")", "conv_out_layers", "=", "512", "return", "conv_out_layers", ",", "height", ",", "width" ]

[ "Calculates", "shape", "of", "data", "after", "encoding", "." ]

[ "def", "calc_im_size", "(", "img_height", ",", "img_width", ")", ":", "height", ",", "width", "=", "img_height", ",", "img_width", "for", "_", "in", "range", "(", "5", ")", ":", "height", ",", "width", "=", "_get_deconv_outsize", "(", "(", "height", ",", "width", ")", ",", "4", ",", "2", ",", "1", ")", "return", "height", ",", "width" ]

[ "Calculates", "shape", "of", "data", "after", "decoding", "." ]

[ "def", "get_paths", "(", "directory", ")", ":", "fnames", "=", "[", "os", ".", "path", ".", "join", "(", "directory", ",", "f", ")", "for", "f", "in", "os", ".", "listdir", "(", "directory", ")", "if", "os", ".", "path", ".", "isfile", "(", "os", ".", "path", ".", "join", "(", "directory", ",", "f", ")", ")", "and", "not", "f", ".", "startswith", "(", "'.'", ")", "]", "return", "fnames" ]

[ "Gets", "all", "the", "paths", "of", "non", "-", "hidden", "files", "in", "a", "directory", "and", "returns", "a", "list", "of", "those", "paths", "." ]

[ "def", "image_resize", "(", "file_paths", ",", "new_dir", ",", "width", ",", "height", ")", ":", "if", "new_dir", "[", "-", "1", "]", "!=", "'/'", ":", "new_dir", "+=", "'/'", "if", "not", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "dirname", "(", "new_dir", ")", ")", ":", "os", ".", "makedirs", "(", "os", ".", "path", ".", "dirname", "(", "new_dir", ")", ")", "for", "f", "in", "tqdm", ".", "tqdm", "(", "file_paths", ")", ":", "img", "=", "Image", ".", "open", "(", "f", ")", ".", "resize", "(", "(", "width", ",", "height", ")", ",", "Image", ".", "ANTIALIAS", ")", ".", "convert", "(", "'RGB'", ")", "new", "=", "os", ".", "path", ".", "join", "(", "new_dir", ",", "os", ".", "path", ".", "basename", "(", "f", ")", ")", "img", ".", "save", "(", "new", ")" ]

[ "Resizes", "all", "images", "with", "given", "paths", "to", "new", "dimensions", ".", "Uses", "up", "/", "downscaling", "with", "antialiasing", "." ]

[ "def", "inverse_transform", "(", "self", ",", "data", ",", "test", "=", "False", ")", ":", "if", "not", "type", "(", "data", ")", "==", "Variable", ":", "if", "len", "(", "data", ".", "shape", ")", "<", "2", ":", "data", "=", "data", "[", "np", ".", "newaxis", "]", "if", "len", "(", "data", ".", "shape", ")", "!=", "2", ":", "raise", "TypeError", "(", "\"Invalid dimensions for latent data. Dim = %s.\\\n Must be a 2d array.\"", "%", "str", "(", "data", ".", "shape", ")", ")", "data", "=", "Variable", "(", "data", ")", "else", ":", "if", "len", "(", "data", ".", "data", ".", "shape", ")", "<", "2", ":", "data", ".", "data", "=", "data", ".", "data", "[", "np", ".", "newaxis", "]", "if", "len", "(", "data", ".", "data", ".", "shape", ")", "!=", "2", ":", "raise", "TypeError", "(", "\"Invalid dimensions for latent data. Dim = %s.\\\n Must be a 2d array.\"", "%", "str", "(", "data", ".", "data", ".", "shape", ")", ")", "assert", "data", ".", "data", ".", "shape", "[", "-", "1", "]", "==", "self", ".", "latent_width", ",", "\"Latent shape %d != %d\"", "%", "(", "data", ".", "data", ".", "shape", "[", "-", "1", "]", ",", "self", ".", "latent_width", ")", "if", "self", ".", "flag_gpu", ":", "data", ".", "to_gpu", "(", ")", "out", "=", "self", ".", "model", ".", "decode", "(", "data", ",", "test", "=", "test", ")", "out", ".", "to_cpu", "(", ")", "if", "self", ".", "mode", "==", "'linear'", ":", "final", "=", "out", ".", "data", "else", ":", "final", "=", "out", ".", "data", ".", "transpose", "(", "0", ",", "2", ",", "3", ",", "1", ")", "return", "final" ]

[ "Transform", "latent", "vectors", "into", "images", "." ]

[ "def", "load_images", "(", "self", ",", "filepaths", ")", ":", "def", "read", "(", "fname", ")", ":", "im", "=", "Image", ".", "open", "(", "fname", ")", "im", "=", "np", ".", "float32", "(", "im", ")", "return", "im", "/", "255.", "x_all", "=", "np", ".", "array", "(", "[", "read", "(", "fname", ")", "for", "fname", "in", "tqdm", ".", "tqdm", "(", "filepaths", ")", "]", ")", "x_all", "=", "x_all", ".", "astype", "(", "'float32'", ")", "if", "self", ".", "mode", "==", "'convolution'", ":", "x_all", "=", "x_all", ".", "transpose", "(", "0", ",", "3", ",", "1", ",", "2", ")", "print", "(", "\"Image Files Loaded!\"", ")", "return", "x_all" ]

[ "Load", "in", "image", "files", "from", "list", "of", "paths", "." ]

[ "def", "fit", "(", "self", ",", "img_data", ",", "save_freq", "=", "-", "1", ",", "pic_freq", "=", "-", "1", ",", "n_epochs", "=", "100", ",", "batch_size", "=", "50", ",", "weight_decay", "=", "True", ",", "model_path", "=", "'./VAE_training_model/'", ",", "img_path", "=", "'./VAE_training_images/'", ",", "img_out_width", "=", "10", ")", ":", "width", "=", "img_out_width", "self", ".", "opt", ".", "setup", "(", "self", ".", "model", ")", "if", "weight_decay", ":", "self", ".", "opt", ".", "add_hook", "(", "chainer", ".", "optimizer", ".", "WeightDecay", "(", "0.00001", ")", ")", "n_data", "=", "img_data", ".", "shape", "[", "0", "]", "batch_iter", "=", "list", "(", "range", "(", "0", ",", "n_data", ",", "batch_size", ")", ")", "n_batches", "=", "len", "(", "batch_iter", ")", "save_counter", "=", "0", "for", "epoch", "in", "range", "(", "1", ",", "n_epochs", "+", "1", ")", ":", "print", "(", "'epoch: %i'", "%", "epoch", ")", "t1", "=", "time", ".", "time", "(", ")", "indexes", "=", "np", ".", "random", ".", "permutation", "(", "n_data", ")", "last_loss_kl", "=", "0.", "last_loss_rec", "=", "0.", "count", "=", "0", "for", "i", "in", "tqdm", ".", "tqdm", "(", "batch_iter", ")", ":", "x_batch", "=", "Variable", "(", "img_data", "[", "indexes", "[", "i", ":", "i", "+", "batch_size", "]", "]", ")", "if", "self", ".", "flag_gpu", ":", "x_batch", ".", "to_gpu", "(", ")", "out", ",", "kl_loss", ",", "rec_loss", "=", "self", ".", "model", ".", "forward", "(", "x_batch", ")", "total_loss", "=", "rec_loss", "+", "kl_loss", "*", "self", ".", "kl_ratio", "self", ".", "opt", ".", "zero_grads", "(", ")", "total_loss", ".", "backward", "(", ")", "self", ".", "opt", ".", "update", "(", ")", "last_loss_kl", "+=", "kl_loss", ".", "data", "last_loss_rec", "+=", "rec_loss", ".", "data", "plot_pics", "=", "Variable", "(", "img_data", "[", "indexes", "[", ":", "width", "]", "]", ")", "count", "+=", "1", "if", "pic_freq", ">", "0", ":", "assert", "type", "(", "pic_freq", ")", "==", "int", ",", "\"pic_freq must be an integer.\"", "if", "count", "%", "pic_freq", "==", "0", ":", "fig", "=", "self", ".", "_plot_img", "(", "plot_pics", ",", "img_path", "=", "img_path", ",", "epoch", "=", "epoch", ")", "display", "(", "fig", ")", "if", "save_freq", ">", "0", ":", "save_counter", "+=", "1", "assert", "type", "(", "save_freq", ")", "==", "int", ",", "\"save_freq must be an integer.\"", "if", "epoch", "%", "save_freq", "==", "0", ":", "name", "=", "\"vae_epoch%s\"", "%", "str", "(", "epoch", ")", "if", "save_counter", "==", "1", ":", "save_meta", "=", "True", "else", ":", "save_meta", "=", "False", "self", ".", "save", "(", "model_path", ",", "name", ",", "save_meta", "=", "save_meta", ")", "fig", "=", "self", ".", "_plot_img", "(", "plot_pics", ",", "img_path", "=", "img_path", ",", "epoch", "=", "epoch", ",", "batch", "=", "n_batches", ",", "save", "=", "True", ")", "msg", "=", "\"rec_loss = {0} , kl_loss = {1}\"", "print", "(", "msg", ".", "format", "(", "last_loss_rec", "/", "n_batches", ",", "last_loss_kl", "/", "n_batches", ")", ")", "t_diff", "=", "time", ".", "time", "(", ")", "-", "t1", "print", "(", "\"time: %f\\n\\n\"", "%", "t_diff", ")" ]

[ "Fit", "the", "VAE", "model", "to", "the", "image", "data", "." ]

[ "def", "save", "(", "self", ",", "path", ",", "name", ",", "save_meta", "=", "True", ")", ":", "_save_model", "(", "self", ".", "model", ",", "str", "(", "path", ")", ",", "\"%s_model\"", "%", "str", "(", "name", ")", ")", "_save_model", "(", "self", ".", "opt", ",", "str", "(", "path", ")", ",", "\"%s_opt\"", "%", "str", "(", "name", ")", ")", "if", "save_meta", ":", "self", ".", "_save_meta", "(", "os", ".", "path", ".", "join", "(", "path", ",", "\"%s_meta\"", "%", "str", "(", "name", ")", ")", ")" ]

[ "Saves", "model", "as", "a", "sequence", "of", "files", "in", "the", "format", ":", "{", "path", "}", "/", "{", "name", "}", "_", "{", "model", "opt", "meta", "}", ".", "h5" ]

[ "def", "load", "(", "cls", ",", "model", ",", "opt", ",", "meta", ",", "flag_gpu", "=", "None", ")", ":", "mess", "=", "\"Model file {0} does not exist. Please check the file path.\"", "assert", "os", ".", "path", ".", "exists", "(", "model", ")", ",", "mess", ".", "format", "(", "model", ")", "assert", "os", ".", "path", ".", "exists", "(", "opt", ")", ",", "mess", ".", "format", "(", "opt", ")", "assert", "os", ".", "path", ".", "exists", "(", "meta", ")", ",", "mess", ".", "format", "(", "meta", ")", "with", "open", "(", "meta", ",", "'r'", ")", "as", "f", ":", "meta", "=", "json", ".", "load", "(", "f", ")", "if", "flag_gpu", "is", "not", "None", ":", "meta", "[", "'flag_gpu'", "]", "=", "flag_gpu", "loaded_class", "=", "cls", "(", "*", "*", "meta", ")", "serializers", ".", "load_hdf5", "(", "model", ",", "loaded_class", ".", "model", ")", "loaded_class", ".", "opt", ".", "setup", "(", "loaded_class", ".", "model", ")", "serializers", ".", "load_hdf5", "(", "opt", ",", "loaded_class", ".", "opt", ")", "if", "meta", "[", "'flag_gpu'", "]", ":", "loaded_class", ".", "model", "=", "loaded_class", ".", "model", ".", "to_gpu", "(", ")", "return", "loaded_class" ]

[ "Loads", "in", "model", "as", "a", "class", "instance", "with", "with", "the", "specified", "model", "and", "optimizer", "states", "." ]

[ "def", "fit", "(", "self", ",", "img_data", ",", "save_freq", "=", "-", "1", ",", "pic_freq", "=", "-", "1", ",", "n_epochs", "=", "100", ",", "batch_size", "=", "50", ",", "weight_decay", "=", "True", ",", "model_path", "=", "'./GAN_training_model/'", ",", "img_path", "=", "'./GAN_training_images/'", ",", "img_out_width", "=", "10", ",", "mirroring", "=", "False", ")", ":", "width", "=", "img_out_width", "self", ".", "dec_opt", ".", "setup", "(", "self", ".", "dec", ")", "self", ".", "disc_opt", ".", "setup", "(", "self", ".", "disc", ")", "if", "weight_decay", ":", "self", ".", "dec_opt", ".", "add_hook", "(", "chainer", ".", "optimizer", ".", "WeightDecay", "(", "0.00001", ")", ")", "self", ".", "disc_opt", ".", "add_hook", "(", "chainer", ".", "optimizer", ".", "WeightDecay", "(", "0.00001", ")", ")", "n_data", "=", "img_data", ".", "shape", "[", "0", "]", "batch_iter", "=", "list", "(", "range", "(", "0", ",", "n_data", ",", "batch_size", ")", ")", "n_batches", "=", "len", "(", "batch_iter", ")", "c_samples", "=", "np", ".", "random", ".", "standard_normal", "(", "(", "width", ",", "self", ".", "latent_width", ")", ")", ".", "astype", "(", "np", ".", "float32", ")", "save_counter", "=", "0", "for", "epoch", "in", "range", "(", "1", ",", "n_epochs", "+", "1", ")", ":", "print", "(", "'epoch: %i'", "%", "epoch", ")", "t1", "=", "time", ".", "time", "(", ")", "indexes", "=", "np", ".", "random", ".", "permutation", "(", "n_data", ")", "last_loss_dec", "=", "0.", "last_loss_disc", "=", "0.", "count", "=", "0", "for", "i", "in", "tqdm", ".", "tqdm", "(", "batch_iter", ")", ":", "x", "=", "img_data", "[", "indexes", "[", "i", ":", "i", "+", "batch_size", "]", "]", "size", "=", "x", ".", "shape", "[", "0", "]", "if", "mirroring", ":", "for", "j", "in", "range", "(", "size", ")", ":", "if", "np", ".", "random", ".", "randint", "(", "2", ")", ":", "x", "[", "j", ",", ":", ",", ":", ",", ":", "]", "=", "x", "[", "j", ",", ":", ",", ":", ",", ":", ":", "-", "1", "]", "x_batch", "=", "Variable", "(", "x", ")", "zeros", "=", "Variable", "(", "np", ".", "zeros", "(", "size", ",", "dtype", "=", "np", ".", "int32", ")", ")", "ones", "=", "Variable", "(", "np", ".", "ones", "(", "size", ",", "dtype", "=", "np", ".", "int32", ")", ")", "if", "self", ".", "flag_gpu", ":", "x_batch", ".", "to_gpu", "(", ")", "zeros", ".", "to_gpu", "(", ")", "ones", ".", "to_gpu", "(", ")", "disc_samp", ",", "disc_batch", "=", "self", ".", "_forward", "(", "x_batch", ")", "L_dec", "=", "F", ".", "softmax_cross_entropy", "(", "disc_samp", ",", "ones", ")", "L_disc", "=", "F", ".", "softmax_cross_entropy", "(", "disc_samp", ",", "zeros", ")", "L_disc", "+=", "F", ".", "softmax_cross_entropy", "(", "disc_batch", ",", "ones", ")", "L_disc", "/=", "2.", "self", ".", "dec_opt", ".", "zero_grads", "(", ")", "L_dec", ".", "backward", "(", ")", "self", ".", "dec_opt", ".", "update", "(", ")", "self", ".", "disc_opt", ".", "zero_grads", "(", ")", "L_disc", ".", "backward", "(", ")", "self", ".", "disc_opt", ".", "update", "(", ")", "last_loss_dec", "+=", "L_dec", ".", "data", "last_loss_disc", "+=", "L_disc", ".", "data", "count", "+=", "1", "if", "pic_freq", ">", "0", ":", "assert", "type", "(", "pic_freq", ")", "==", "int", ",", "\"pic_freq must be an integer.\"", "if", "count", "%", "pic_freq", "==", "0", ":", "fig", "=", "self", ".", "_plot_img", "(", "c_samples", ",", "img_path", "=", "img_path", ",", "epoch", "=", "epoch", ")", "display", "(", "fig", ")", "if", "save_freq", ">", "0", ":", "save_counter", "+=", "1", "assert", "type", "(", "save_freq", ")", "==", "int", ",", "\"save_freq must be an integer.\"", "if", "epoch", "%", "save_freq", "==", "0", ":", "name", "=", "\"gan_epoch%s\"", "%", "str", "(", "epoch", ")", "if", "save_counter", "==", "1", ":", "save_meta", "=", "True", "else", ":", "save_meta", "=", "False", "self", ".", "save", "(", "model_path", ",", "name", ",", "save_meta", "=", "save_meta", ")", "fig", "=", "self", ".", "_plot_img", "(", "c_samples", ",", "img_path", "=", "img_path", ",", "epoch", "=", "epoch", ",", "batch", "=", "n_batches", ",", "save_pic", "=", "True", ")", "msg", "=", "\"dec_loss = {0} , disc_loss = {1}\"", "print", "(", "msg", ".", "format", "(", "last_loss_dec", "/", "n_batches", ",", "last_loss_disc", "/", "n_batches", ")", ")", "t_diff", "=", "time", ".", "time", "(", ")", "-", "t1", "print", "(", "\"time: %f\\n\\n\"", "%", "t_diff", ")" ]

[ "Fit", "the", "GAN", "model", "to", "the", "image", "data", "." ]

[ "def", "save", "(", "self", ",", "path", ",", "name", ",", "save_meta", "=", "True", ")", ":", "_save_model", "(", "self", ".", "dec", ",", "str", "(", "path", ")", ",", "\"%s_dec\"", "%", "str", "(", "name", ")", ")", "_save_model", "(", "self", ".", "disc", ",", "str", "(", "path", ")", ",", "\"%s_disc\"", "%", "str", "(", "name", ")", ")", "_save_model", "(", "self", ".", "dec_opt", ",", "str", "(", "path", ")", ",", "\"%s_dec_opt\"", "%", "str", "(", "name", ")", ")", "_save_model", "(", "self", ".", "disc_opt", ",", "str", "(", "path", ")", ",", "\"%s_disc_opt\"", "%", "str", "(", "name", ")", ")", "if", "save_meta", ":", "self", ".", "_save_meta", "(", "os", ".", "path", ".", "join", "(", "path", ",", "\"%s_meta\"", "%", "str", "(", "name", ")", ")", ")" ]

[ "Saves", "model", "as", "a", "sequence", "of", "files", "in", "the", "format", ":", "{", "path", "}", "/", "{", "name", "}", "_", "{", "dec", "disc", "dec_opt", "disc_opt", "meta", "}", ".", "h5" ]

[ "def", "transform", "(", "self", ",", "data", ",", "test", "=", "False", ")", ":", "#make sure that data has the right shape.", "if", "not", "type", "(", "data", ")", "==", "Variable", ":", "if", "len", "(", "data", ".", "shape", ")", "<", "4", ":", "data", "=", "data", "[", "np", ".", "newaxis", "]", "if", "len", "(", "data", ".", "shape", ")", "!=", "4", ":", "raise", "TypeError", "(", "\"Invalid dimensions for image data. Dim = %s.\\\n Must be 4d array.\"", "%", "str", "(", "data", ".", "shape", ")", ")", "if", "data", ".", "shape", "[", "1", "]", "!=", "self", ".", "color_channels", ":", "if", "data", ".", "shape", "[", "-", "1", "]", "==", "self", ".", "color_channels", ":", "data", "=", "data", ".", "transpose", "(", "0", ",", "3", ",", "1", ",", "2", ")", "else", ":", "raise", "TypeError", "(", "\"Invalid dimensions for image data. Dim = %s\"", "%", "str", "(", "data", ".", "shape", ")", ")", "data", "=", "Variable", "(", "data", ")", "else", ":", "if", "len", "(", "data", ".", "data", ".", "shape", ")", "<", "4", ":", "data", ".", "data", "=", "data", ".", "data", "[", "np", ".", "newaxis", "]", "if", "len", "(", "data", ".", "data", ".", "shape", ")", "!=", "4", ":", "raise", "TypeError", "(", "\"Invalid dimensions for image data. Dim = %s.\\\n Must be 4d array.\"", "%", "str", "(", "data", ".", "data", ".", "shape", ")", ")", "if", "data", ".", "data", ".", "shape", "[", "1", "]", "!=", "self", ".", "color_channels", ":", "if", "data", ".", "data", ".", "shape", "[", "-", "1", "]", "==", "self", ".", "color_channels", ":", "data", ".", "data", "=", "data", ".", "data", ".", "transpose", "(", "0", ",", "3", ",", "1", ",", "2", ")", "else", ":", "raise", "TypeError", "(", "\"Invalid dimensions for image data. Dim = %s\"", "%", "str", "(", "data", ".", "shape", ")", ")", "# Actual transformation.", "if", "self", ".", "flag_gpu", ":", "data", ".", "to_gpu", "(", ")", "z", "=", "self", ".", "_encode", "(", "data", ",", "test", "=", "test", ")", "[", "0", "]", "z", ".", "to_cpu", "(", ")", "return", "z", ".", "data" ]

[ "Transform", "image", "data", "to", "latent", "space", "." ]

[ "def", "fit", "(", "self", ",", "img_data", ",", "gamma", "=", "1.0", ",", "save_freq", "=", "-", "1", ",", "pic_freq", "=", "-", "1", ",", "n_epochs", "=", "100", ",", "batch_size", "=", "50", ",", "weight_decay", "=", "True", ",", "model_path", "=", "'./VAEGAN_training_model/'", ",", "img_path", "=", "'./VAEGAN_training_images/'", ",", "img_out_width", "=", "10", ",", "mirroring", "=", "False", ")", ":", "width", "=", "img_out_width", "self", ".", "enc_opt", ".", "setup", "(", "self", ".", "enc", ")", "self", ".", "dec_opt", ".", "setup", "(", "self", ".", "dec", ")", "self", ".", "disc_opt", ".", "setup", "(", "self", ".", "disc", ")", "if", "weight_decay", ":", "self", ".", "enc_opt", ".", "add_hook", "(", "chainer", ".", "optimizer", ".", "WeightDecay", "(", "0.00001", ")", ")", "self", ".", "dec_opt", ".", "add_hook", "(", "chainer", ".", "optimizer", ".", "WeightDecay", "(", "0.00001", ")", ")", "self", ".", "disc_opt", ".", "add_hook", "(", "chainer", ".", "optimizer", ".", "WeightDecay", "(", "0.00001", ")", ")", "n_data", "=", "img_data", ".", "shape", "[", "0", "]", "batch_iter", "=", "list", "(", "range", "(", "0", ",", "n_data", ",", "batch_size", ")", ")", "n_batches", "=", "len", "(", "batch_iter", ")", "c_samples", "=", "np", ".", "random", ".", "standard_normal", "(", "(", "width", ",", "self", ".", "latent_width", ")", ")", ".", "astype", "(", "np", ".", "float32", ")", "save_counter", "=", "0", "for", "epoch", "in", "range", "(", "1", ",", "n_epochs", "+", "1", ")", ":", "print", "(", "'epoch: %i'", "%", "epoch", ")", "t1", "=", "time", ".", "time", "(", ")", "indexes", "=", "np", ".", "random", ".", "permutation", "(", "n_data", ")", "sum_l_enc", "=", "0.", "sum_l_dec", "=", "0.", "sum_l_disc", "=", "0.", "sum_l_gan", "=", "0.", "sum_l_like", "=", "0.", "sum_l_prior", "=", "0.", "count", "=", "0", "for", "i", "in", "tqdm", ".", "tqdm", "(", "batch_iter", ")", ":", "x", "=", "img_data", "[", "indexes", "[", "i", ":", "i", "+", "batch_size", "]", "]", "size", "=", "x", ".", "shape", "[", "0", "]", "if", "mirroring", ":", "for", "j", "in", "range", "(", "size", ")", ":", "if", "np", ".", "random", ".", "randint", "(", "2", ")", ":", "x", "[", "j", ",", ":", ",", ":", ",", ":", "]", "=", "x", "[", "j", ",", ":", ",", ":", ",", ":", ":", "-", "1", "]", "x_batch", "=", "Variable", "(", "x", ")", "zeros", "=", "Variable", "(", "np", ".", "zeros", "(", "size", ",", "dtype", "=", "np", ".", "int32", ")", ")", "ones", "=", "Variable", "(", "np", ".", "ones", "(", "size", ",", "dtype", "=", "np", ".", "int32", ")", ")", "if", "self", ".", "flag_gpu", ":", "x_batch", ".", "to_gpu", "(", ")", "zeros", ".", "to_gpu", "(", ")", "ones", ".", "to_gpu", "(", ")", "kl_loss", ",", "dif_l", ",", "disc_rec", ",", "disc_batch", ",", "disc_samp", "=", "self", ".", "_forward", "(", "x_batch", ")", "L_batch_GAN", "=", "F", ".", "softmax_cross_entropy", "(", "disc_batch", ",", "ones", ")", "L_rec_GAN", "=", "F", ".", "softmax_cross_entropy", "(", "disc_rec", ",", "zeros", ")", "L_samp_GAN", "=", "F", ".", "softmax_cross_entropy", "(", "disc_samp", ",", "zeros", ")", "l_gan", "=", "(", "L_batch_GAN", "+", "L_rec_GAN", "+", "L_samp_GAN", ")", "/", "3.", "l_like", "=", "dif_l", "l_prior", "=", "kl_loss", "enc_loss", "=", "self", ".", "kl_ratio", "*", "l_prior", "+", "l_like", "dec_loss", "=", "gamma", "*", "l_like", "-", "l_gan", "disc_loss", "=", "l_gan", "self", ".", "enc_opt", ".", "zero_grads", "(", ")", "enc_loss", ".", "backward", "(", ")", "self", ".", "enc_opt", ".", "update", "(", ")", "self", ".", "dec_opt", ".", "zero_grads", "(", ")", "dec_loss", ".", "backward", "(", ")", "self", ".", "dec_opt", ".", "update", "(", ")", "self", ".", "disc_opt", ".", "zero_grads", "(", ")", "disc_loss", ".", "backward", "(", ")", "self", ".", "disc_opt", ".", "update", "(", ")", "sum_l_enc", "+=", "enc_loss", ".", "data", "sum_l_dec", "+=", "dec_loss", ".", "data", "sum_l_disc", "+=", "disc_loss", ".", "data", "sum_l_gan", "+=", "l_gan", ".", "data", "sum_l_like", "+=", "l_like", ".", "data", "sum_l_prior", "+=", "l_prior", ".", "data", "count", "+=", "1", "plot_data", "=", "img_data", "[", "indexes", "[", ":", "width", "]", "]", "if", "pic_freq", ">", "0", ":", "assert", "type", "(", "pic_freq", ")", "==", "int", ",", "\"pic_freq must be an integer.\"", "if", "count", "%", "pic_freq", "==", "0", ":", "fig", "=", "self", ".", "_plot_img", "(", "plot_data", ",", "c_samples", ",", "img_path", "=", "img_path", ",", "epoch", "=", "epoch", ")", "display", "(", "fig", ")", "if", "save_freq", ">", "0", ":", "save_counter", "+=", "1", "assert", "type", "(", "save_freq", ")", "==", "int", ",", "\"save_freq must be an integer.\"", "if", "epoch", "%", "save_freq", "==", "0", ":", "name", "=", "\"vaegan_epoch%s\"", "%", "str", "(", "epoch", ")", "if", "save_counter", "==", "1", ":", "save_meta", "=", "True", "else", ":", "save_meta", "=", "False", "self", ".", "save", "(", "model_path", ",", "name", ",", "save_meta", "=", "save_meta", ")", "fig", "=", "self", ".", "_plot_img", "(", "plot_data", ",", "c_samples", ",", "img_path", "=", "img_path", ",", "epoch", "=", "epoch", ",", "batch", "=", "n_batches", ",", "save_pic", "=", "True", ")", "sum_l_enc", "/=", "n_batches", "sum_l_dec", "/=", "n_batches", "sum_l_disc", "/=", "n_batches", "sum_l_gan", "/=", "n_batches", "sum_l_like", "/=", "n_batches", "sum_l_prior", "/=", "n_batches", "msg", "=", "\"enc_loss = {0}, dec_loss = {1} , disc_loss = {2}\"", "msg2", "=", "\"gan_loss = {0}, sim_loss = {1}, kl_loss = {2}\"", "print", "(", "msg", ".", "format", "(", "sum_l_enc", ",", "sum_l_dec", ",", "sum_l_disc", ")", ")", "print", "(", "msg2", ".", "format", "(", "sum_l_gan", ",", "sum_l_like", ",", "sum_l_prior", ")", ")", "t_diff", "=", "time", ".", "time", "(", ")", "-", "t1", "print", "(", "\"time: %f\\n\\n\"", "%", "t_diff", ")" ]

[ "Fit", "the", "VAE", "/", "GAN", "model", "to", "the", "image", "data", "." ]

[ "def", "load", "(", "cls", ",", "enc", ",", "dec", ",", "disc", ",", "enc_opt", ",", "dec_opt", ",", "disc_opt", ",", "meta", ",", "flag_gpu", "=", "None", ")", ":", "mess", "=", "\"Model file {0} does not exist. Please check the file path.\"", "assert", "os", ".", "path", ".", "exists", "(", "enc", ")", ",", "mess", ".", "format", "(", "enc", ")", "assert", "os", ".", "path", ".", "exists", "(", "dec", ")", ",", "mess", ".", "format", "(", "dec", ")", "assert", "os", ".", "path", ".", "exists", "(", "disc", ")", ",", "mess", ".", "format", "(", "disc", ")", "assert", "os", ".", "path", ".", "exists", "(", "dec_opt", ")", ",", "mess", ".", "format", "(", "dec_opt", ")", "assert", "os", ".", "path", ".", "exists", "(", "disc_opt", ")", ",", "mess", ".", "format", "(", "disc_opt", ")", "assert", "os", ".", "path", ".", "exists", "(", "meta", ")", ",", "mess", ".", "format", "(", "meta", ")", "with", "open", "(", "meta", ",", "'r'", ")", "as", "f", ":", "meta", "=", "json", ".", "load", "(", "f", ")", "if", "flag_gpu", "is", "not", "None", ":", "meta", "[", "'flag_gpu'", "]", "=", "flag_gpu", "loaded_class", "=", "cls", "(", "*", "*", "meta", ")", "serializers", ".", "load_hdf5", "(", "enc", ",", "loaded_class", ".", "enc", ")", "serializers", ".", "load_hdf5", "(", "dec", ",", "loaded_class", ".", "dec", ")", "serializers", ".", "load_hdf5", "(", "disc", ",", "loaded_class", ".", "disc", ")", "loaded_class", ".", "enc_opt", ".", "setup", "(", "loaded_class", ".", "enc", ")", "loaded_class", ".", "dec_opt", ".", "setup", "(", "loaded_class", ".", "dec", ")", "loaded_class", ".", "disc_opt", ".", "setup", "(", "loaded_class", ".", "disc", ")", "serializers", ".", "load_hdf5", "(", "enc_opt", ",", "loaded_class", ".", "enc_opt", ")", "serializers", ".", "load_hdf5", "(", "dec_opt", ",", "loaded_class", ".", "dec_opt", ")", "serializers", ".", "load_hdf5", "(", "disc_opt", ",", "loaded_class", ".", "disc_opt", ")", "if", "meta", "[", "'flag_gpu'", "]", ":", "loaded_class", ".", "enc", ".", "to_gpu", "(", ")", "loaded_class", ".", "dec", ".", "to_gpu", "(", ")", "loaded_class", ".", "disc", ".", "to_gpu", "(", ")", "return", "loaded_class" ]

[ "Loads", "in", "model", "as", "a", "class", "instance", "with", "with", "the", "specified", "model", "and", "optimizer", "states", "." ]

[ "def", "polynomial_sign", "(", "poly_surface", ",", "degree", ")", ":", "# The indices where the corner nodes in a surface are.", "corner_indices", "=", "(", "0", ",", "degree", ",", "-", "1", ")", "sub_polys", "=", "[", "poly_surface", "]", "signs", "=", "set", "(", ")", "for", "_", "in", "six", ".", "moves", ".", "xrange", "(", "_MAX_POLY_SUBDIVISIONS", ")", ":", "undecided", "=", "[", "]", "for", "poly", "in", "sub_polys", ":", "# First add all the signs of the corner nodes.", "signs", ".", "update", "(", "_SIGN", "(", "poly", "[", "0", ",", "corner_indices", "]", ")", ".", "astype", "(", "int", ")", ")", "# Then check if the ``poly`` nodes are **uniformly** one sign.", "if", "np", ".", "all", "(", "poly", "==", "0.0", ")", ":", "signs", ".", "add", "(", "0", ")", "elif", "np", ".", "all", "(", "poly", ">", "0.0", ")", ":", "signs", ".", "add", "(", "1", ")", "elif", "np", ".", "all", "(", "poly", "<", "0.0", ")", ":", "signs", ".", "add", "(", "-", "1", ")", "else", ":", "undecided", ".", "append", "(", "poly", ")", "if", "len", "(", "signs", ")", ">", "1", ":", "return", "0", "sub_polys", "=", "functools", ".", "reduce", "(", "operator", ".", "add", ",", "[", "subdivide_nodes", "(", "poly", ",", "degree", ")", "for", "poly", "in", "undecided", "]", ",", "(", ")", ",", ")", "if", "not", "sub_polys", ":", "break", "if", "sub_polys", ":", "raise", "ValueError", "(", "\"Did not reach a conclusion after max subdivisions\"", ",", "_MAX_POLY_SUBDIVISIONS", ",", ")", "else", ":", "# NOTE: We are guaranteed that ``len(signs) <= 1``.", "return", "signs", ".", "pop", "(", ")" ]

[ "r", "Determine", "the", "sign", "of", "a", "polynomial", "on", "the", "reference", "triangle", "." ]

[ "def", "quadratic_jacobian_polynomial", "(", "nodes", ")", ":", "# First evaluate the Jacobian at each of the 6 nodes.", "jac_parts", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "_QUADRATIC_JACOBIAN_HELPER", ")", "jac_at_nodes", "=", "np", ".", "empty", "(", "(", "1", ",", "6", ")", ",", "order", "=", "\"F\"", ")", "jac_at_nodes", "[", "0", ",", "0", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", ":", "2", "]", ")", "jac_at_nodes", "[", "0", ",", "1", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "2", ":", "4", "]", ")", "jac_at_nodes", "[", "0", ",", "2", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "4", ":", "6", "]", ")", "jac_at_nodes", "[", "0", ",", "3", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "6", ":", "8", "]", ")", "jac_at_nodes", "[", "0", ",", "4", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "8", ":", "10", "]", ")", "jac_at_nodes", "[", "0", ",", "5", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "10", ":", "]", ")", "# Convert the nodal values to the Bernstein basis...", "bernstein", "=", "_helpers", ".", "matrix_product", "(", "jac_at_nodes", ",", "_QUADRATIC_TO_BERNSTEIN", ")", "return", "bernstein" ]

[ "r", "Compute", "the", "Jacobian", "determinant", "of", "a", "quadratic", "surface", "." ]

[ "def", "cubic_jacobian_polynomial", "(", "nodes", ")", ":", "# First evaluate the Jacobian at each of the 15 nodes", "# in the quartic triangle.", "jac_parts", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "_CUBIC_JACOBIAN_HELPER", ")", "jac_at_nodes", "=", "np", ".", "empty", "(", "(", "1", ",", "15", ")", ",", "order", "=", "\"F\"", ")", "jac_at_nodes", "[", "0", ",", "0", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", ":", "2", "]", ")", "jac_at_nodes", "[", "0", ",", "1", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "2", ":", "4", "]", ")", "jac_at_nodes", "[", "0", ",", "2", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "4", ":", "6", "]", ")", "jac_at_nodes", "[", "0", ",", "3", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "6", ":", "8", "]", ")", "jac_at_nodes", "[", "0", ",", "4", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "8", ":", "10", "]", ")", "jac_at_nodes", "[", "0", ",", "5", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "10", ":", "12", "]", ")", "jac_at_nodes", "[", "0", ",", "6", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "12", ":", "14", "]", ")", "jac_at_nodes", "[", "0", ",", "7", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "14", ":", "16", "]", ")", "jac_at_nodes", "[", "0", ",", "8", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "16", ":", "18", "]", ")", "jac_at_nodes", "[", "0", ",", "9", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "18", ":", "20", "]", ")", "jac_at_nodes", "[", "0", ",", "10", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "20", ":", "22", "]", ")", "jac_at_nodes", "[", "0", ",", "11", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "22", ":", "24", "]", ")", "jac_at_nodes", "[", "0", ",", "12", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "24", ":", "26", "]", ")", "jac_at_nodes", "[", "0", ",", "13", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "26", ":", "28", "]", ")", "jac_at_nodes", "[", "0", ",", "14", "]", "=", "two_by_two_det", "(", "jac_parts", "[", ":", ",", "28", ":", "]", ")", "# Convert the nodal values to the Bernstein basis...", "bernstein", "=", "_helpers", ".", "matrix_product", "(", "jac_at_nodes", ",", "_QUARTIC_TO_BERNSTEIN", ")", "bernstein", "/=", "_QUARTIC_BERNSTEIN_FACTOR", "return", "bernstein" ]

[ "r", "Compute", "the", "Jacobian", "determinant", "of", "a", "cubic", "surface", "." ]

[ "def", "_de_casteljau_one_round", "(", "nodes", ",", "degree", ",", "lambda1", ",", "lambda2", ",", "lambda3", ")", ":", "dimension", ",", "num_nodes", "=", "nodes", ".", "shape", "num_new_nodes", "=", "num_nodes", "-", "degree", "-", "1", "new_nodes", "=", "np", ".", "empty", "(", "(", "dimension", ",", "num_new_nodes", ")", ",", "order", "=", "\"F\"", ")", "index", "=", "0", "# parent_i1 = index + k", "# parent_i2 = index + k + 1", "# parent_i3 = index + degree + 1", "parent_i1", "=", "0", "parent_i2", "=", "1", "parent_i3", "=", "degree", "+", "1", "for", "k", "in", "six", ".", "moves", ".", "xrange", "(", "degree", ")", ":", "for", "unused_j", "in", "six", ".", "moves", ".", "xrange", "(", "degree", "-", "k", ")", ":", "# NOTE: i = (degree - 1) - j - k", "new_nodes", "[", ":", ",", "index", "]", "=", "(", "lambda1", "*", "nodes", "[", ":", ",", "parent_i1", "]", "+", "lambda2", "*", "nodes", "[", ":", ",", "parent_i2", "]", "+", "lambda3", "*", "nodes", "[", ":", ",", "parent_i3", "]", ")", "# Update all the indices.", "parent_i1", "+=", "1", "parent_i2", "+=", "1", "parent_i3", "+=", "1", "index", "+=", "1", "# Update the indices that depend on k.", "parent_i1", "+=", "1", "parent_i2", "+=", "1", "return", "new_nodes" ]

[ "r", "Performs", "one", "round", "of", "the", "de", "Casteljau", "algorithm", "for", "surfaces", "." ]

[ "def", "make_transform", "(", "degree", ",", "weights_a", ",", "weights_b", ",", "weights_c", ")", ":", "num_nodes", "=", "(", "(", "degree", "+", "1", ")", "*", "(", "degree", "+", "2", ")", ")", "//", "2", "id_mat", "=", "np", ".", "eye", "(", "num_nodes", ",", "order", "=", "\"F\"", ")", "# Pre-compute the matrices that do the reduction so we don't", "# have to **actually** perform the de Casteljau algorithm", "# every time.", "transform", "=", "{", "0", ":", "de_casteljau_one_round", "(", "id_mat", ",", "degree", ",", "*", "weights_a", ")", ",", "1", ":", "de_casteljau_one_round", "(", "id_mat", ",", "degree", ",", "*", "weights_b", ")", ",", "2", ":", "de_casteljau_one_round", "(", "id_mat", ",", "degree", ",", "*", "weights_c", ")", ",", "}", "return", "transform" ]

[ "Compute", "matrices", "corresponding", "to", "the", "de", "Casteljau", "algorithm", "." ]

[ "def", "reduced_to_matrix", "(", "shape", ",", "degree", ",", "vals_by_weight", ")", ":", "result", "=", "np", ".", "empty", "(", "shape", ",", "order", "=", "\"F\"", ")", "index", "=", "0", "for", "k", "in", "six", ".", "moves", ".", "xrange", "(", "degree", "+", "1", ")", ":", "for", "j", "in", "six", ".", "moves", ".", "xrange", "(", "degree", "+", "1", "-", "k", ")", ":", "i", "=", "degree", "-", "j", "-", "k", "key", "=", "(", "0", ",", ")", "*", "i", "+", "(", "1", ",", ")", "*", "j", "+", "(", "2", ",", ")", "*", "k", "result", "[", ":", ",", "index", "]", "=", "vals_by_weight", "[", "key", "]", "[", ":", ",", "0", "]", "index", "+=", "1", "return", "result" ]

[ "r", "Converts", "a", "reduced", "values", "dictionary", "into", "a", "matrix", "." ]

[ "def", "_specialize_surface", "(", "nodes", ",", "degree", ",", "weights_a", ",", "weights_b", ",", "weights_c", ")", ":", "# Uses A-->0, B-->1, C-->2 to represent the specialization used.", "partial_vals", "=", "{", "(", "0", ",", ")", ":", "de_casteljau_one_round", "(", "nodes", ",", "degree", ",", "*", "weights_a", ")", ",", "(", "1", ",", ")", ":", "de_casteljau_one_round", "(", "nodes", ",", "degree", ",", "*", "weights_b", ")", ",", "(", "2", ",", ")", ":", "de_casteljau_one_round", "(", "nodes", ",", "degree", ",", "*", "weights_c", ")", ",", "}", "for", "reduced_deg", "in", "six", ".", "moves", ".", "xrange", "(", "degree", "-", "1", ",", "0", ",", "-", "1", ")", ":", "new_partial", "=", "{", "}", "transform", "=", "make_transform", "(", "reduced_deg", ",", "weights_a", ",", "weights_b", ",", "weights_c", ")", "for", "key", ",", "sub_nodes", "in", "six", ".", "iteritems", "(", "partial_vals", ")", ":", "# Our keys are ascending so we increment from the last value.", "for", "next_id", "in", "six", ".", "moves", ".", "xrange", "(", "key", "[", "-", "1", "]", ",", "2", "+", "1", ")", ":", "new_key", "=", "key", "+", "(", "next_id", ",", ")", "new_partial", "[", "new_key", "]", "=", "_helpers", ".", "matrix_product", "(", "sub_nodes", ",", "transform", "[", "next_id", "]", ")", "partial_vals", "=", "new_partial", "return", "reduced_to_matrix", "(", "nodes", ".", "shape", ",", "degree", ",", "partial_vals", ")" ]

[ "Specialize", "a", "surface", "to", "a", "reparameterization" ]

[ "def", "_subdivide_nodes", "(", "nodes", ",", "degree", ")", ":", "if", "degree", "==", "1", ":", "nodes_a", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "LINEAR_SUBDIVIDE_A", ")", "nodes_b", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "LINEAR_SUBDIVIDE_B", ")", "nodes_c", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "LINEAR_SUBDIVIDE_C", ")", "nodes_d", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "LINEAR_SUBDIVIDE_D", ")", "elif", "degree", "==", "2", ":", "nodes_a", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "QUADRATIC_SUBDIVIDE_A", ")", "nodes_b", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "QUADRATIC_SUBDIVIDE_B", ")", "nodes_c", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "QUADRATIC_SUBDIVIDE_C", ")", "nodes_d", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "QUADRATIC_SUBDIVIDE_D", ")", "elif", "degree", "==", "3", ":", "nodes_a", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "CUBIC_SUBDIVIDE_A", ")", "nodes_b", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "CUBIC_SUBDIVIDE_B", ")", "nodes_c", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "CUBIC_SUBDIVIDE_C", ")", "nodes_d", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "CUBIC_SUBDIVIDE_D", ")", "elif", "degree", "==", "4", ":", "nodes_a", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "QUARTIC_SUBDIVIDE_A", ")", "nodes_b", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "QUARTIC_SUBDIVIDE_B", ")", "nodes_c", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "QUARTIC_SUBDIVIDE_C", ")", "nodes_d", "=", "_helpers", ".", "matrix_product", "(", "nodes", ",", "QUARTIC_SUBDIVIDE_D", ")", "else", ":", "nodes_a", "=", "specialize_surface", "(", "nodes", ",", "degree", ",", "_WEIGHTS_SUBDIVIDE0", ",", "_WEIGHTS_SUBDIVIDE1", ",", "_WEIGHTS_SUBDIVIDE2", ",", ")", "nodes_b", "=", "specialize_surface", "(", "nodes", ",", "degree", ",", "_WEIGHTS_SUBDIVIDE3", ",", "_WEIGHTS_SUBDIVIDE2", ",", "_WEIGHTS_SUBDIVIDE1", ",", ")", "nodes_c", "=", "specialize_surface", "(", "nodes", ",", "degree", ",", "_WEIGHTS_SUBDIVIDE1", ",", "_WEIGHTS_SUBDIVIDE4", ",", "_WEIGHTS_SUBDIVIDE3", ",", ")", "nodes_d", "=", "specialize_surface", "(", "nodes", ",", "degree", ",", "_WEIGHTS_SUBDIVIDE2", ",", "_WEIGHTS_SUBDIVIDE3", ",", "_WEIGHTS_SUBDIVIDE5", ",", ")", "return", "nodes_a", ",", "nodes_b", ",", "nodes_c", ",", "nodes_d" ]

[ "Subdivide", "a", "surface", "into", "four", "sub", "-", "surfaces", "." ]

[ "def", "jacobian_s", "(", "nodes", ",", "degree", ",", "dimension", ")", ":", "num_nodes", "=", "(", "degree", "*", "(", "degree", "+", "1", ")", ")", "//", "2", "result", "=", "np", ".", "empty", "(", "(", "dimension", ",", "num_nodes", ")", ",", "order", "=", "\"F\"", ")", "index", "=", "0", "i", "=", "0", "for", "num_vals", "in", "six", ".", "moves", ".", "xrange", "(", "degree", ",", "0", ",", "-", "1", ")", ":", "for", "_", "in", "six", ".", "moves", ".", "xrange", "(", "num_vals", ")", ":", "result", "[", ":", ",", "index", "]", "=", "nodes", "[", ":", ",", "i", "+", "1", "]", "-", "nodes", "[", ":", ",", "i", "]", "# Update the indices", "index", "+=", "1", "i", "+=", "1", "# In between each row, the index gains an extra value.", "i", "+=", "1", "return", "float", "(", "degree", ")", "*", "result" ]

[ "r", "Compute", ":", "math", ":", "\\", "frac", "{", "\\", "partial", "B", "}", "{", "\\", "partial", "s", "}", "." ]

[ "def", "_jacobian_both", "(", "nodes", ",", "degree", ",", "dimension", ")", ":", "_", ",", "num_nodes", "=", "nodes", ".", "shape", "result", "=", "np", ".", "empty", "(", "(", "2", "*", "dimension", ",", "num_nodes", "-", "degree", "-", "1", ")", ",", "order", "=", "\"F\"", ")", "result", "[", ":", "dimension", ",", ":", "]", "=", "jacobian_s", "(", "nodes", ",", "degree", ",", "dimension", ")", "result", "[", "dimension", ":", ",", ":", "]", "=", "jacobian_t", "(", "nodes", ",", "degree", ",", "dimension", ")", "return", "result" ]

[ "r", "Compute", ":", "math", ":", "s", "and", ":", "math", ":", "t", "partial", "of", ":", "math", ":", "B", "." ]

[ "def", "_jacobian_det", "(", "nodes", ",", "degree", ",", "st_vals", ")", ":", "jac_nodes", "=", "jacobian_both", "(", "nodes", ",", "degree", ",", "2", ")", "if", "degree", "==", "1", ":", "num_vals", ",", "_", "=", "st_vals", ".", "shape", "bs_bt_vals", "=", "np", ".", "repeat", "(", "jac_nodes", ",", "num_vals", ",", "axis", "=", "1", ")", "else", ":", "bs_bt_vals", "=", "evaluate_cartesian_multi", "(", "jac_nodes", ",", "degree", "-", "1", ",", "st_vals", ",", "4", ")", "# Take the determinant for each (s, t).", "return", "(", "bs_bt_vals", "[", "0", ",", ":", "]", "*", "bs_bt_vals", "[", "3", ",", ":", "]", "-", "bs_bt_vals", "[", "1", ",", ":", "]", "*", "bs_bt_vals", "[", "2", ",", ":", "]", ")" ]

[ "r", "Compute", ":", "math", ":", "\\", "det", "(", "D", "B", ")", "at", "a", "set", "of", "values", "." ]

[ "def", "classify_tangent_intersection", "(", "intersection", ",", "nodes1", ",", "tangent1", ",", "nodes2", ",", "tangent2", ")", ":", "# Each array is 2 x 1 (i.e. a column vector), we want the vector", "# dot product.", "dot_prod", "=", "np", ".", "vdot", "(", "tangent1", "[", ":", ",", "0", "]", ",", "tangent2", "[", ":", ",", "0", "]", ")", "# NOTE: When computing curvatures we assume that we don't have lines", "# here, because lines that are tangent at an intersection are", "# parallel and we don't handle that case.", "curvature1", "=", "_curve_helpers", ".", "get_curvature", "(", "nodes1", ",", "tangent1", ",", "intersection", ".", "s", ")", "curvature2", "=", "_curve_helpers", ".", "get_curvature", "(", "nodes2", ",", "tangent2", ",", "intersection", ".", "t", ")", "if", "dot_prod", "<", "0", ":", "# If the tangent vectors are pointing in the opposite direction,", "# then the curves are facing opposite directions.", "sign1", ",", "sign2", "=", "_SIGN", "(", "[", "curvature1", ",", "curvature2", "]", ")", "if", "sign1", "==", "sign2", ":", "# If both curvatures are positive, since the curves are", "# moving in opposite directions, the tangency isn't part of", "# the surface intersection.", "if", "sign1", "==", "1.0", ":", "return", "CLASSIFICATION_T", ".", "OPPOSED", "else", ":", "return", "CLASSIFICATION_T", ".", "TANGENT_BOTH", "else", ":", "delta_c", "=", "abs", "(", "curvature1", ")", "-", "abs", "(", "curvature2", ")", "if", "delta_c", "==", "0.0", ":", "raise", "NotImplementedError", "(", "_SAME_CURVATURE", ")", "elif", "sign1", "==", "_SIGN", "(", "delta_c", ")", ":", "return", "CLASSIFICATION_T", ".", "OPPOSED", "else", ":", "return", "CLASSIFICATION_T", ".", "TANGENT_BOTH", "else", ":", "if", "curvature1", ">", "curvature2", ":", "return", "CLASSIFICATION_T", ".", "TANGENT_FIRST", "elif", "curvature1", "<", "curvature2", ":", "return", "CLASSIFICATION_T", ".", "TANGENT_SECOND", "else", ":", "raise", "NotImplementedError", "(", "_SAME_CURVATURE", ")" ]

[ "Helper", "for", "func", ":", "classify_intersection", "at", "tangencies", "." ]

[ "def", "ignored_edge_corner", "(", "edge_tangent", ",", "corner_tangent", ",", "corner_previous_edge", ")", ":", "cross_prod", "=", "_helpers", ".", "cross_product", "(", "edge_tangent", ".", "ravel", "(", "order", "=", "\"F\"", ")", ",", "corner_tangent", ".", "ravel", "(", "order", "=", "\"F\"", ")", ")", "# A negative cross product indicates that ``edge_tangent`` is", "# \"inside\" / \"to the left\" of ``corner_tangent`` (due to right-hand rule).", "if", "cross_prod", ">", "0.0", ":", "return", "False", "# Do the same for the **other** tangent at the corner.", "alt_corner_tangent", "=", "_curve_helpers", ".", "evaluate_hodograph", "(", "1.0", ",", "corner_previous_edge", ")", "# Change the direction of the \"in\" tangent so that it points \"out\".", "alt_corner_tangent", "*=", "-", "1.0", "cross_prod", "=", "_helpers", ".", "cross_product", "(", "edge_tangent", ".", "ravel", "(", "order", "=", "\"F\"", ")", ",", "alt_corner_tangent", ".", "ravel", "(", "order", "=", "\"F\"", ")", ")", "return", "cross_prod", "<=", "0.0" ]

[ "Check", "ignored", "when", "a", "corner", "lies", "**", "inside", "**", "another", "edge", "." ]

[ "def", "ignored_double_corner", "(", "intersection", ",", "tangent_s", ",", "tangent_t", ",", "edge_nodes1", ",", "edge_nodes2", ")", ":", "# Compute the other edge for the ``s`` surface.", "prev_index", "=", "(", "intersection", ".", "index_first", "-", "1", ")", "%", "3", "prev_edge", "=", "edge_nodes1", "[", "prev_index", "]", "alt_tangent_s", "=", "_curve_helpers", ".", "evaluate_hodograph", "(", "1.0", ",", "prev_edge", ")", "# First check if ``tangent_t`` is interior to the ``s`` surface.", "cross_prod1", "=", "_helpers", ".", "cross_product", "(", "tangent_s", ".", "ravel", "(", "order", "=", "\"F\"", ")", ",", "tangent_t", ".", "ravel", "(", "order", "=", "\"F\"", ")", ")", "# A positive cross product indicates that ``tangent_t`` is", "# interior to ``tangent_s``. Similar for ``alt_tangent_s``.", "# If ``tangent_t`` is interior to both, then the surfaces", "# do more than just \"kiss\" at the corner, so the corner should", "# not be ignored.", "if", "cross_prod1", ">=", "0.0", ":", "# Only compute ``cross_prod2`` if we need to.", "cross_prod2", "=", "_helpers", ".", "cross_product", "(", "alt_tangent_s", ".", "ravel", "(", "order", "=", "\"F\"", ")", ",", "tangent_t", ".", "ravel", "(", "order", "=", "\"F\"", ")", ")", "if", "cross_prod2", ">=", "0.0", ":", "return", "False", "# If ``tangent_t`` is not interior, we check the other ``t``", "# edge that ends at the corner.", "prev_index", "=", "(", "intersection", ".", "index_second", "-", "1", ")", "%", "3", "prev_edge", "=", "edge_nodes2", "[", "prev_index", "]", "alt_tangent_t", "=", "_curve_helpers", ".", "evaluate_hodograph", "(", "1.0", ",", "prev_edge", ")", "# Change the direction of the \"in\" tangent so that it points \"out\".", "alt_tangent_t", "*=", "-", "1.0", "cross_prod3", "=", "_helpers", ".", "cross_product", "(", "tangent_s", ".", "ravel", "(", "order", "=", "\"F\"", ")", ",", "alt_tangent_t", ".", "ravel", "(", "order", "=", "\"F\"", ")", ")", "if", "cross_prod3", ">=", "0.0", ":", "# Only compute ``cross_prod4`` if we need to.", "cross_prod4", "=", "_helpers", ".", "cross_product", "(", "alt_tangent_s", ".", "ravel", "(", "order", "=", "\"F\"", ")", ",", "alt_tangent_t", ".", "ravel", "(", "order", "=", "\"F\"", ")", ")", "if", "cross_prod4", ">=", "0.0", ":", "return", "False", "# If neither of ``tangent_t`` or ``alt_tangent_t`` are interior", "# to the ``s`` surface, one of two things is true. Either", "# the two surfaces have no interior intersection (1) or the", "# ``s`` surface is bounded by both edges of the ``t`` surface", "# at the corner intersection (2). To detect (2), we only need", "# check if ``tangent_s`` is interior to both ``tangent_t``", "# and ``alt_tangent_t``. ``cross_prod1`` contains", "# (tangent_s) x (tangent_t), so it's negative will tell if", "# ``tangent_s`` is interior. Similarly, ``cross_prod3``", "# contains (tangent_s) x (alt_tangent_t), but we also reversed", "# the sign on ``alt_tangent_t`` so switching the sign back", "# and reversing the arguments in the cross product cancel out.", "return", "cross_prod1", ">", "0.0", "or", "cross_prod3", "<", "0.0" ]

[ "Check", "if", "an", "intersection", "is", "an", "ignored", "double", "corner", "." ]

[ "def", "ignored_corner", "(", "intersection", ",", "tangent_s", ",", "tangent_t", ",", "edge_nodes1", ",", "edge_nodes2", ")", ":", "if", "intersection", ".", "s", "==", "0.0", ":", "if", "intersection", ".", "t", "==", "0.0", ":", "# Double corner.", "return", "ignored_double_corner", "(", "intersection", ",", "tangent_s", ",", "tangent_t", ",", "edge_nodes1", ",", "edge_nodes2", ")", "else", ":", "# s-only corner.", "prev_index", "=", "(", "intersection", ".", "index_first", "-", "1", ")", "%", "3", "prev_edge", "=", "edge_nodes1", "[", "prev_index", "]", "return", "ignored_edge_corner", "(", "tangent_t", ",", "tangent_s", ",", "prev_edge", ")", "elif", "intersection", ".", "t", "==", "0.0", ":", "# t-only corner.", "prev_index", "=", "(", "intersection", ".", "index_second", "-", "1", ")", "%", "3", "prev_edge", "=", "edge_nodes2", "[", "prev_index", "]", "return", "ignored_edge_corner", "(", "tangent_s", ",", "tangent_t", ",", "prev_edge", ")", "else", ":", "# Not a corner.", "return", "False" ]

[ "Check", "if", "an", "intersection", "is", "an", "ignored", "corner", "." ]

[ "def", "classify_intersection", "(", "intersection", ",", "edge_nodes1", ",", "edge_nodes2", ")", ":", "if", "intersection", ".", "s", "==", "1.0", "or", "intersection", ".", "t", "==", "1.0", ":", "raise", "ValueError", "(", "\"Intersection occurs at the end of an edge\"", ",", "\"s\"", ",", "intersection", ".", "s", ",", "\"t\"", ",", "intersection", ".", "t", ",", ")", "nodes1", "=", "edge_nodes1", "[", "intersection", ".", "index_first", "]", "tangent1", "=", "_curve_helpers", ".", "evaluate_hodograph", "(", "intersection", ".", "s", ",", "nodes1", ")", "nodes2", "=", "edge_nodes2", "[", "intersection", ".", "index_second", "]", "tangent2", "=", "_curve_helpers", ".", "evaluate_hodograph", "(", "intersection", ".", "t", ",", "nodes2", ")", "if", "ignored_corner", "(", "intersection", ",", "tangent1", ",", "tangent2", ",", "edge_nodes1", ",", "edge_nodes2", ")", ":", "return", "CLASSIFICATION_T", ".", "IGNORED_CORNER", "# Take the cross product of tangent vectors to determine which one", "# is more \"inside\" / \"to the left\".", "cross_prod", "=", "_helpers", ".", "cross_product", "(", "tangent1", ".", "ravel", "(", "order", "=", "\"F\"", ")", ",", "tangent2", ".", "ravel", "(", "order", "=", "\"F\"", ")", ")", "if", "cross_prod", "<", "-", "ALMOST_TANGENT", ":", "return", "CLASSIFICATION_T", ".", "FIRST", "elif", "cross_prod", ">", "ALMOST_TANGENT", ":", "return", "CLASSIFICATION_T", ".", "SECOND", "else", ":", "# NOTE: A more robust approach would take ||tangent1|| and ||tangent2||", "# into account when comparing (tangent1 x tangent2) to the", "# \"almost zero\" threshold. We (for now) avoid doing this because", "# normalizing the tangent vectors has a \"cost\" of ~6 flops each", "# and that cost would happen for **every** single intersection.", "return", "classify_tangent_intersection", "(", "intersection", ",", "nodes1", ",", "tangent1", ",", "nodes2", ",", "tangent2", ")" ]

[ "r", "Determine", "which", "curve", "is", "on", "the", "inside", "of", "the", "intersection", "." ]

[ "def", "handle_ends", "(", "index1", ",", "s", ",", "index2", ",", "t", ")", ":", "edge_end", "=", "False", "if", "s", "==", "1.0", ":", "s", "=", "0.0", "index1", "=", "(", "index1", "+", "1", ")", "%", "3", "edge_end", "=", "True", "# NOTE: This is not a typo, the values can be updated twice if both ``s``", "# and ``t`` are ``1.0``", "if", "t", "==", "1.0", ":", "t", "=", "0.0", "index2", "=", "(", "index2", "+", "1", ")", "%", "3", "edge_end", "=", "True", "is_corner", "=", "s", "==", "0.0", "or", "t", "==", "0.0", "return", "edge_end", ",", "is_corner", ",", "(", "index1", ",", "s", ",", "index2", ",", "t", ")" ]

[ "Updates", "intersection", "parameters", "if", "it", "is", "on", "the", "end", "of", "an", "edge", "." ]

[ "def", "to_front", "(", "intersection", ",", "intersections", ",", "unused", ")", ":", "if", "intersection", ".", "s", "==", "1.0", ":", "next_index", "=", "(", "intersection", ".", "index_first", "+", "1", ")", "%", "3", "# Make sure we haven't accidentally ignored an existing intersection.", "for", "other_int", "in", "intersections", ":", "if", "other_int", ".", "s", "==", "0.0", "and", "other_int", ".", "index_first", "==", "next_index", ":", "if", "other_int", "in", "unused", ":", "unused", ".", "remove", "(", "other_int", ")", "return", "other_int", "# If we haven't already returned, create **another** artificial", "# intersection.", "return", "_intersection_helpers", ".", "Intersection", "(", "next_index", ",", "0.0", ",", "None", ",", "None", ",", "interior_curve", "=", "CLASSIFICATION_T", ".", "FIRST", ")", "elif", "intersection", ".", "t", "==", "1.0", ":", "# NOTE: We assume, but do not check, that ``s == 1.0`` and ``t == 1.0``", "# are mutually exclusive.", "next_index", "=", "(", "intersection", ".", "index_second", "+", "1", ")", "%", "3", "# Make sure we haven't accidentally ignored an existing intersection.", "for", "other_int", "in", "intersections", ":", "if", "other_int", ".", "t", "==", "0.0", "and", "other_int", ".", "index_second", "==", "next_index", ":", "if", "other_int", "in", "unused", ":", "unused", ".", "remove", "(", "other_int", ")", "return", "other_int", "# If we haven't already returned, create **another** artificial", "# intersection.", "return", "_intersection_helpers", ".", "Intersection", "(", "None", ",", "None", ",", "next_index", ",", "0.0", ",", "interior_curve", "=", "CLASSIFICATION_T", ".", "SECOND", ")", "else", ":", "return", "intersection" ]

[ "Rotates", "a", "node", "to", "the", "front", "." ]

[ "def", "get_next_first", "(", "intersection", ",", "intersections", ",", "to_end", "=", "True", ")", ":", "along_edge", "=", "None", "index_first", "=", "intersection", ".", "index_first", "s", "=", "intersection", ".", "s", "for", "other_int", "in", "intersections", ":", "other_s", "=", "other_int", ".", "s", "if", "other_int", ".", "index_first", "==", "index_first", "and", "other_s", ">", "s", ":", "if", "along_edge", "is", "None", "or", "other_s", "<", "along_edge", ".", "s", ":", "along_edge", "=", "other_int", "if", "along_edge", "is", "None", ":", "if", "to_end", ":", "# If there is no other intersection on the edge, just return", "# the segment end.", "return", "_intersection_helpers", ".", "Intersection", "(", "index_first", ",", "1.0", ",", "None", ",", "None", ",", "interior_curve", "=", "CLASSIFICATION_T", ".", "FIRST", ",", ")", "else", ":", "return", "None", "else", ":", "return", "along_edge" ]

[ "Gets", "the", "next", "node", "along", "the", "current", "(", "first", ")", "edge", "." ]

[ "def", "get_next_second", "(", "intersection", ",", "intersections", ",", "to_end", "=", "True", ")", ":", "along_edge", "=", "None", "index_second", "=", "intersection", ".", "index_second", "t", "=", "intersection", ".", "t", "for", "other_int", "in", "intersections", ":", "other_t", "=", "other_int", ".", "t", "if", "other_int", ".", "index_second", "==", "index_second", "and", "other_t", ">", "t", ":", "if", "along_edge", "is", "None", "or", "other_t", "<", "along_edge", ".", "t", ":", "along_edge", "=", "other_int", "if", "along_edge", "is", "None", ":", "if", "to_end", ":", "# If there is no other intersection on the edge, just return", "# the segment end.", "return", "_intersection_helpers", ".", "Intersection", "(", "None", ",", "None", ",", "index_second", ",", "1.0", ",", "interior_curve", "=", "CLASSIFICATION_T", ".", "SECOND", ",", ")", "else", ":", "return", "None", "else", ":", "return", "along_edge" ]

[ "Gets", "the", "next", "node", "along", "the", "current", "(", "second", ")", "edge", "." ]

[ "def", "get_next_coincident", "(", "intersection", ",", "intersections", ")", ":", "# Moving along the first or second edge will produce the same result, but", "# since we \"rotate\" all intersections to the beginning of an edge, the", "# index may not match the first or second (or both).", "along_first", "=", "get_next_first", "(", "intersection", ",", "intersections", ",", "to_end", "=", "False", ")", "if", "along_first", "is", "None", ":", "along_second", "=", "get_next_second", "(", "intersection", ",", "intersections", ",", "to_end", "=", "False", ")", "else", ":", "return", "along_first", "if", "along_second", "is", "None", ":", "return", "_intersection_helpers", ".", "Intersection", "(", "intersection", ".", "index_first", ",", "1.0", ",", "intersection", ".", "index_second", ",", "1.0", ",", "interior_curve", "=", "CLASSIFICATION_T", ".", "COINCIDENT", ",", ")", "else", ":", "return", "along_second" ]

[ "Gets", "the", "next", "node", "along", "the", "current", "(", "coincident", ")", "edge", "." ]

[ "def", "get_next", "(", "intersection", ",", "intersections", ",", "unused", ")", ":", "result", "=", "None", "if", "is_first", "(", "intersection", ".", "interior_curve", ")", ":", "result", "=", "get_next_first", "(", "intersection", ",", "intersections", ")", "elif", "is_second", "(", "intersection", ".", "interior_curve", ")", ":", "result", "=", "get_next_second", "(", "intersection", ",", "intersections", ")", "elif", "intersection", ".", "interior_curve", "==", "CLASSIFICATION_T", ".", "COINCIDENT", ":", "result", "=", "get_next_coincident", "(", "intersection", ",", "intersections", ")", "else", ":", "raise", "ValueError", "(", "'Cannot get next node if not starting from \"FIRST\", '", "'\"TANGENT_FIRST\", \"SECOND\", \"TANGENT_SECOND\" or \"COINCIDENT\".'", ")", "if", "result", "in", "unused", ":", "unused", ".", "remove", "(", "result", ")", "return", "result" ]

[ "Gets", "the", "next", "node", "along", "a", "given", "edge", "." ]

[ "def", "ends_to_curve", "(", "start_node", ",", "end_node", ")", ":", "if", "is_first", "(", "start_node", ".", "interior_curve", ")", ":", "if", "end_node", ".", "index_first", "!=", "start_node", ".", "index_first", ":", "raise", "ValueError", "(", "_WRONG_CURVE", ")", "return", "start_node", ".", "index_first", ",", "start_node", ".", "s", ",", "end_node", ".", "s", "elif", "is_second", "(", "start_node", ".", "interior_curve", ")", ":", "if", "end_node", ".", "index_second", "!=", "start_node", ".", "index_second", ":", "raise", "ValueError", "(", "_WRONG_CURVE", ")", "return", "start_node", ".", "index_second", "+", "3", ",", "start_node", ".", "t", ",", "end_node", ".", "t", "elif", "start_node", ".", "interior_curve", "==", "CLASSIFICATION_T", ".", "COINCIDENT", ":", "if", "end_node", ".", "index_first", "==", "start_node", ".", "index_first", ":", "return", "start_node", ".", "index_first", ",", "start_node", ".", "s", ",", "end_node", ".", "s", "elif", "end_node", ".", "index_second", "==", "start_node", ".", "index_second", ":", "return", "start_node", ".", "index_second", "+", "3", ",", "start_node", ".", "t", ",", "end_node", ".", "t", "else", ":", "raise", "ValueError", "(", "_WRONG_CURVE", ")", "else", ":", "raise", "ValueError", "(", "'Segment start must be classified as \"FIRST\", \"TANGENT_FIRST\", '", "'\"SECOND\", \"TANGENT_SECOND\" or \"COINCIDENT\".'", ")" ]

[ "Convert", "a", "pair", "of", "intersection", "nodes", "to", "a", "curve", "segment", "." ]

[ "def", "no_intersections", "(", "nodes1", ",", "degree1", ",", "nodes2", ",", "degree2", ")", ":", "# NOTE: This is a circular import.", "from", "bezier", "import", "_surface_intersection", "located", "=", "_surface_intersection", ".", "locate_point", "(", "nodes2", ",", "degree2", ",", "nodes1", "[", "0", ",", "0", "]", ",", "nodes1", "[", "1", ",", "0", "]", ")", "if", "located", "is", "not", "None", ":", "return", "None", ",", "True", "located", "=", "_surface_intersection", ".", "locate_point", "(", "nodes1", ",", "degree1", ",", "nodes2", "[", "0", ",", "0", "]", ",", "nodes2", "[", "1", ",", "0", "]", ")", "if", "located", "is", "not", "None", ":", "return", "None", ",", "False", "return", "[", "]", ",", "None" ]

[ "r", "Determine", "if", "one", "surface", "is", "in", "the", "other", "." ]

[ "def", "tangent_only_intersections", "(", "all_types", ")", ":", "if", "len", "(", "all_types", ")", "!=", "1", ":", "raise", "ValueError", "(", "\"Unexpected value, types should all match\"", ",", "all_types", ")", "point_type", "=", "all_types", ".", "pop", "(", ")", "if", "point_type", "==", "CLASSIFICATION_T", ".", "OPPOSED", ":", "return", "[", "]", ",", "None", "elif", "point_type", "==", "CLASSIFICATION_T", ".", "IGNORED_CORNER", ":", "return", "[", "]", ",", "None", "elif", "point_type", "==", "CLASSIFICATION_T", ".", "TANGENT_FIRST", ":", "return", "None", ",", "True", "elif", "point_type", "==", "CLASSIFICATION_T", ".", "TANGENT_SECOND", ":", "return", "None", ",", "False", "elif", "point_type", "==", "CLASSIFICATION_T", ".", "COINCIDENT_UNUSED", ":", "return", "[", "]", ",", "None", "else", ":", "raise", "ValueError", "(", "\"Point type not for tangency\"", ",", "point_type", ")" ]

[ "Determine", "intersection", "in", "the", "case", "of", "only", "-", "tangent", "intersections", "." ]

[ "def", "basic_interior_combine", "(", "intersections", ",", "max_edges", "=", "10", ")", ":", "unused", "=", "intersections", "[", ":", "]", "result", "=", "[", "]", "while", "unused", ":", "start", "=", "unused", ".", "pop", "(", ")", "curr_node", "=", "start", "next_node", "=", "get_next", "(", "curr_node", ",", "intersections", ",", "unused", ")", "edge_ends", "=", "[", "(", "curr_node", ",", "next_node", ")", "]", "while", "next_node", "is", "not", "start", ":", "curr_node", "=", "to_front", "(", "next_node", ",", "intersections", ",", "unused", ")", "# NOTE: We also check to break when moving a corner node", "# to the front. This is because ``intersections``", "# de-duplicates corners by selecting the one", "# (of 2 or 4 choices) at the front of segment(s).", "if", "curr_node", "is", "start", ":", "break", "next_node", "=", "get_next", "(", "curr_node", ",", "intersections", ",", "unused", ")", "edge_ends", ".", "append", "(", "(", "curr_node", ",", "next_node", ")", ")", "if", "len", "(", "edge_ends", ")", ">", "max_edges", ":", "raise", "RuntimeError", "(", "\"Unexpected number of edges\"", ",", "len", "(", "edge_ends", ")", ")", "edge_info", "=", "tuple", "(", "ends_to_curve", "(", "start_node", ",", "end_node", ")", "for", "start_node", ",", "end_node", "in", "edge_ends", ")", "result", ".", "append", "(", "edge_info", ")", "if", "len", "(", "result", ")", "==", "1", ":", "if", "result", "[", "0", "]", "in", "FIRST_SURFACE_INFO", ":", "return", "None", ",", "True", "elif", "result", "[", "0", "]", "in", "SECOND_SURFACE_INFO", ":", "return", "None", ",", "False", "return", "result", ",", "None" ]

[ "Combine", "intersections", "that", "don", "t", "involve", "tangencies", "." ]

[ "def", "combine_intersections", "(", "intersections", ",", "nodes1", ",", "degree1", ",", "nodes2", ",", "degree2", ",", "all_types", ")", ":", "if", "intersections", ":", "return", "basic_interior_combine", "(", "intersections", ")", "elif", "all_types", ":", "return", "tangent_only_intersections", "(", "all_types", ")", "else", ":", "return", "no_intersections", "(", "nodes1", ",", "degree1", ",", "nodes2", ",", "degree2", ")" ]

[ "r", "Combine", "curve", "-", "curve", "intersections", "into", "curved", "polygon", "(", "s", ")", "." ]

[ "def", "_evaluate_barycentric", "(", "nodes", ",", "degree", ",", "lambda1", ",", "lambda2", ",", "lambda3", ")", ":", "dimension", ",", "num_nodes", "=", "nodes", ".", "shape", "binom_val", "=", "1.0", "result", "=", "np", ".", "zeros", "(", "(", "dimension", ",", "1", ")", ",", "order", "=", "\"F\"", ")", "index", "=", "num_nodes", "-", "1", "result", "[", ":", ",", "0", "]", "+=", "nodes", "[", ":", ",", "index", "]", "# curve evaluate_multi_barycentric() takes arrays.", "lambda1", "=", "np", ".", "asfortranarray", "(", "[", "lambda1", "]", ")", "lambda2", "=", "np", ".", "asfortranarray", "(", "[", "lambda2", "]", ")", "for", "k", "in", "six", ".", "moves", ".", "xrange", "(", "degree", "-", "1", ",", "-", "1", ",", "-", "1", ")", ":", "# We want to go from (d C (k + 1)) to (d C k).", "binom_val", "=", "(", "binom_val", "*", "(", "k", "+", "1", ")", ")", "/", "(", "degree", "-", "k", ")", "index", "-=", "1", "# Step to last element in column.", "# k = d - 1, d - 2, ...", "# d - k = 1, 2, ...", "# We know column k has (d - k + 1) elements.", "new_index", "=", "index", "-", "degree", "+", "k", "# First element in column.", "col_nodes", "=", "nodes", "[", ":", ",", "new_index", ":", "index", "+", "1", "]", "# noqa: E203", "col_nodes", "=", "np", ".", "asfortranarray", "(", "col_nodes", ")", "col_result", "=", "_curve_helpers", ".", "evaluate_multi_barycentric", "(", "col_nodes", ",", "lambda1", ",", "lambda2", ")", "result", "*=", "lambda3", "result", "+=", "binom_val", "*", "col_result", "# Update index for next iteration.", "index", "=", "new_index", "return", "result" ]

[ "r", "Compute", "a", "point", "on", "a", "surface", "." ]

[ "def", "_evaluate_barycentric_multi", "(", "nodes", ",", "degree", ",", "param_vals", ",", "dimension", ")", ":", "num_vals", ",", "_", "=", "param_vals", ".", "shape", "result", "=", "np", ".", "empty", "(", "(", "dimension", ",", "num_vals", ")", ",", "order", "=", "\"F\"", ")", "for", "index", ",", "(", "lambda1", ",", "lambda2", ",", "lambda3", ")", "in", "enumerate", "(", "param_vals", ")", ":", "result", "[", ":", ",", "index", "]", "=", "evaluate_barycentric", "(", "nodes", ",", "degree", ",", "lambda1", ",", "lambda2", ",", "lambda3", ")", "[", ":", ",", "0", "]", "return", "result" ]

[ "r", "Compute", "multiple", "points", "on", "the", "surface", "." ]

[ "def", "_evaluate_cartesian_multi", "(", "nodes", ",", "degree", ",", "param_vals", ",", "dimension", ")", ":", "num_vals", ",", "_", "=", "param_vals", ".", "shape", "result", "=", "np", ".", "empty", "(", "(", "dimension", ",", "num_vals", ")", ",", "order", "=", "\"F\"", ")", "for", "index", ",", "(", "s", ",", "t", ")", "in", "enumerate", "(", "param_vals", ")", ":", "result", "[", ":", ",", "index", "]", "=", "evaluate_barycentric", "(", "nodes", ",", "degree", ",", "1.0", "-", "s", "-", "t", ",", "s", ",", "t", ")", "[", ":", ",", "0", "]", "return", "result" ]

[ "r", "Compute", "multiple", "points", "on", "the", "surface", "." ]

[ "def", "_compute_edge_nodes", "(", "nodes", ",", "degree", ")", ":", "dimension", ",", "_", "=", "np", ".", "shape", "(", "nodes", ")", "nodes1", "=", "np", ".", "empty", "(", "(", "dimension", ",", "degree", "+", "1", ")", ",", "order", "=", "\"F\"", ")", "nodes2", "=", "np", ".", "empty", "(", "(", "dimension", ",", "degree", "+", "1", ")", ",", "order", "=", "\"F\"", ")", "nodes3", "=", "np", ".", "empty", "(", "(", "dimension", ",", "degree", "+", "1", ")", ",", "order", "=", "\"F\"", ")", "curr2", "=", "degree", "curr3", "=", "-", "1", "for", "i", "in", "six", ".", "moves", ".", "xrange", "(", "degree", "+", "1", ")", ":", "nodes1", "[", ":", ",", "i", "]", "=", "nodes", "[", ":", ",", "i", "]", "nodes2", "[", ":", ",", "i", "]", "=", "nodes", "[", ":", ",", "curr2", "]", "nodes3", "[", ":", ",", "i", "]", "=", "nodes", "[", ":", ",", "curr3", "]", "# Update the indices.", "curr2", "+=", "degree", "-", "i", "curr3", "-=", "i", "+", "2", "return", "nodes1", ",", "nodes2", ",", "nodes3" ]

[ "Compute", "the", "nodes", "of", "each", "edges", "of", "a", "surface", "." ]

[ "def", "shoelace_for_area", "(", "nodes", ")", ":", "_", ",", "num_nodes", "=", "nodes", ".", "shape", "if", "num_nodes", "==", "2", ":", "shoelace", "=", "SHOELACE_LINEAR", "scale_factor", "=", "2.0", "elif", "num_nodes", "==", "3", ":", "shoelace", "=", "SHOELACE_QUADRATIC", "scale_factor", "=", "6.0", "elif", "num_nodes", "==", "4", ":", "shoelace", "=", "SHOELACE_CUBIC", "scale_factor", "=", "20.0", "elif", "num_nodes", "==", "5", ":", "shoelace", "=", "SHOELACE_QUARTIC", "scale_factor", "=", "70.0", "else", ":", "raise", "_helpers", ".", "UnsupportedDegree", "(", "num_nodes", "-", "1", ",", "supported", "=", "(", "1", ",", "2", ",", "3", ",", "4", ")", ")", "result", "=", "0.0", "for", "multiplier", ",", "index1", ",", "index2", "in", "shoelace", ":", "result", "+=", "multiplier", "*", "(", "nodes", "[", "0", ",", "index1", "]", "*", "nodes", "[", "1", ",", "index2", "]", "-", "nodes", "[", "1", ",", "index1", "]", "*", "nodes", "[", "0", ",", "index2", "]", ")", "return", "result", "/", "scale_factor" ]

[ "r", "Compute", "an", "auxiliary", "shoelace", "sum", "used", "to", "compute", "area", "." ]

[ "def", "save_image", "(", "figure", ",", "filename", ")", ":", "path", "=", "os", ".", "path", ".", "join", "(", "IMAGES_DIR", ",", "filename", ")", "figure", ".", "savefig", "(", "path", ",", "bbox_inches", "=", "\"tight\"", ")", "plt", ".", "close", "(", "figure", ")" ]

[ "Save", "an", "image", "to", "the", "docs", "images", "directory", "." ]

[ "def", "stack1d", "(", "*", "points", ")", ":", "result", "=", "np", ".", "empty", "(", "(", "2", ",", "len", "(", "points", ")", ")", ",", "order", "=", "\"F\"", ")", "for", "index", ",", "point", "in", "enumerate", "(", "points", ")", ":", "result", "[", ":", ",", "index", "]", "=", "point", "return", "result" ]

[ "Fill", "out", "the", "columns", "of", "matrix", "with", "a", "series", "of", "points", "." ]

[ "def", "linearization_error", "(", "nodes", ")", ":", "if", "NO_IMAGES", ":", "return", "curve", "=", "bezier", ".", "Curve", ".", "from_nodes", "(", "nodes", ")", "line", "=", "bezier", ".", "Curve", ".", "from_nodes", "(", "nodes", "[", ":", ",", "(", "0", ",", "-", "1", ")", "]", ")", "midpoints", "=", "np", ".", "hstack", "(", "[", "curve", ".", "evaluate", "(", "0.5", ")", ",", "line", ".", "evaluate", "(", "0.5", ")", "]", ")", "ax", "=", "curve", ".", "plot", "(", "256", ")", "line", ".", "plot", "(", "256", ",", "ax", "=", "ax", ")", "ax", ".", "plot", "(", "midpoints", "[", "0", ",", ":", "]", ",", "midpoints", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"dashed\"", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "save_image", "(", "ax", ".", "figure", ",", "\"linearization_error.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "linearization_error", "docstring", "." ]

[ "def", "newton_refine1", "(", "s", ",", "new_s", ",", "curve1", ",", "t", ",", "new_t", ",", "curve2", ")", ":", "if", "NO_IMAGES", ":", "return", "points", "=", "np", ".", "hstack", "(", "[", "curve1", ".", "evaluate", "(", "s", ")", ",", "curve2", ".", "evaluate", "(", "t", ")", "]", ")", "points_new", "=", "np", ".", "hstack", "(", "[", "curve1", ".", "evaluate", "(", "new_s", ")", ",", "curve2", ".", "evaluate", "(", "new_t", ")", "]", ")", "ax", "=", "curve1", ".", "plot", "(", "256", ")", "curve2", ".", "plot", "(", "256", ",", "ax", "=", "ax", ")", "ax", ".", "plot", "(", "points", "[", "0", ",", ":", "]", ",", "points", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ",", "markeredgewidth", "=", "1", ",", "markerfacecolor", "=", "\"None\"", ",", ")", "ax", ".", "plot", "(", "points_new", "[", "0", ",", ":", "]", ",", "points_new", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ",", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "save_image", "(", "ax", ".", "figure", ",", "\"newton_refine1.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "newton_refine", "docstring", "." ]

[ "def", "newton_refine2", "(", "s_vals", ",", "curve1", ",", "curve2", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "curve1", ".", "plot", "(", "256", ")", "ax", ".", "lines", "[", "-", "1", "]", ".", "zorder", "=", "1", "curve2", ".", "plot", "(", "256", ",", "ax", "=", "ax", ")", "ax", ".", "lines", "[", "-", "1", "]", ".", "zorder", "=", "1", "points", "=", "curve1", ".", "evaluate_multi", "(", "np", ".", "asfortranarray", "(", "s_vals", ")", ")", "colors", "=", "seaborn", ".", "dark_palette", "(", "\"blue\"", ",", "5", ")", "ax", ".", "scatter", "(", "points", "[", "0", ",", ":", "]", ",", "points", "[", "1", ",", ":", "]", ",", "c", "=", "colors", ",", "s", "=", "20", ",", "alpha", "=", "0.75", ",", "zorder", "=", "2", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "0.0", ",", "1.0", ")", "ax", ".", "set_ylim", "(", "0.0", ",", "1.0", ")", "save_image", "(", "ax", ".", "figure", ",", "\"newton_refine2.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "newton_refine", "docstring", "." ]

[ "def", "segment_intersection1", "(", "start0", ",", "end0", ",", "start1", ",", "end1", ",", "s", ")", ":", "if", "NO_IMAGES", ":", "return", "line0", "=", "bezier", ".", "Curve", ".", "from_nodes", "(", "stack1d", "(", "start0", ",", "end0", ")", ")", "line1", "=", "bezier", ".", "Curve", ".", "from_nodes", "(", "stack1d", "(", "start1", ",", "end1", ")", ")", "ax", "=", "line0", ".", "plot", "(", "2", ")", "line1", ".", "plot", "(", "256", ",", "ax", "=", "ax", ")", "(", "x_val", ",", ")", ",", "(", "y_val", ",", ")", "=", "line0", ".", "evaluate", "(", "s", ")", "ax", ".", "plot", "(", "[", "x_val", "]", ",", "[", "y_val", "]", ",", "color", "=", "\"black\"", ",", "marker", "=", "\"o\"", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "save_image", "(", "ax", ".", "figure", ",", "\"segment_intersection1.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "segment_intersection", "docstring", "." ]

[ "def", "segment_intersection2", "(", "start0", ",", "end0", ",", "start1", ",", "end1", ")", ":", "if", "NO_IMAGES", ":", "return", "line0", "=", "bezier", ".", "Curve", ".", "from_nodes", "(", "stack1d", "(", "start0", ",", "end0", ")", ")", "line1", "=", "bezier", ".", "Curve", ".", "from_nodes", "(", "stack1d", "(", "start1", ",", "end1", ")", ")", "ax", "=", "line0", ".", "plot", "(", "2", ")", "line1", ".", "plot", "(", "2", ",", "ax", "=", "ax", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "save_image", "(", "ax", ".", "figure", ",", "\"segment_intersection2.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "segment_intersection", "docstring", "." ]

[ "def", "helper_parallel_lines", "(", "start0", ",", "end0", ",", "start1", ",", "end1", ",", "filename", ")", ":", "if", "NO_IMAGES", ":", "return", "figure", "=", "plt", ".", "figure", "(", ")", "ax", "=", "figure", ".", "gca", "(", ")", "points", "=", "stack1d", "(", "start0", ",", "end0", ",", "start1", ",", "end1", ")", "ax", ".", "plot", "(", "points", "[", "0", ",", ":", "2", "]", ",", "points", "[", "1", ",", ":", "2", "]", ",", "marker", "=", "\"o\"", ")", "ax", ".", "plot", "(", "points", "[", "0", ",", "2", ":", "]", ",", "points", "[", "1", ",", "2", ":", "]", ",", "marker", "=", "\"o\"", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "_plot_helpers", ".", "add_plot_boundary", "(", "ax", ")", "save_image", "(", "figure", ",", "filename", ")" ]

[ "Image", "for", ":", "func", ":", ".", "parallel_lines_parameters", "docstring", "." ]

[ "def", "curve_constructor", "(", "curve", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "curve", ".", "plot", "(", "256", ")", "line", "=", "ax", ".", "lines", "[", "0", "]", "nodes", "=", "curve", ".", "_nodes", "ax", ".", "plot", "(", "nodes", "[", "0", ",", ":", "]", ",", "nodes", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ")", "add_patch", "(", "ax", ",", "nodes", ",", "line", ".", "get_color", "(", ")", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.125", ",", "1.125", ")", "ax", ".", "set_ylim", "(", "-", "0.0625", ",", "0.5625", ")", "save_image", "(", "ax", ".", "figure", ",", "\"curve_constructor.png\"", ")" ]

[ "Image", "for", ":", "class", ".", "Curve", "docstring", "." ]

[ "def", "curve_evaluate", "(", "curve", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "curve", ".", "plot", "(", "256", ")", "points", "=", "curve", ".", "evaluate_multi", "(", "np", ".", "asfortranarray", "(", "[", "0.75", "]", ")", ")", "ax", ".", "plot", "(", "points", "[", "0", ",", ":", "]", ",", "points", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.125", ",", "1.125", ")", "ax", ".", "set_ylim", "(", "-", "0.0625", ",", "0.5625", ")", "save_image", "(", "ax", ".", "figure", ",", "\"curve_evaluate.png\"", ")" ]

[ "Image", "for", ":", "meth", ".", "Curve", ".", "evaluate", "docstring", "." ]

[ "def", "curve_subdivide", "(", "curve", ",", "left", ",", "right", ")", ":", "if", "NO_IMAGES", ":", "return", "figure", "=", "plt", ".", "figure", "(", ")", "ax", "=", "figure", ".", "gca", "(", ")", "add_patch", "(", "ax", ",", "curve", ".", "_nodes", ",", "\"gray\"", ")", "ax", "=", "left", ".", "plot", "(", "256", ",", "ax", "=", "ax", ")", "line", "=", "ax", ".", "lines", "[", "-", "1", "]", "add_patch", "(", "ax", ",", "left", ".", "_nodes", ",", "line", ".", "get_color", "(", ")", ")", "right", ".", "plot", "(", "256", ",", "ax", "=", "ax", ")", "line", "=", "ax", ".", "lines", "[", "-", "1", "]", "add_patch", "(", "ax", ",", "right", ".", "_nodes", ",", "line", ".", "get_color", "(", ")", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.125", ",", "2.125", ")", "ax", ".", "set_ylim", "(", "-", "0.125", ",", "3.125", ")", "save_image", "(", "ax", ".", "figure", ",", "\"curve_subdivide.png\"", ")" ]

[ "Image", "for", ":", "meth", ".", "Curve", ".", "subdivide", "docstring", "." ]

[ "def", "curve_intersect", "(", "curve1", ",", "curve2", ",", "s_vals", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "curve1", ".", "plot", "(", "256", ")", "curve2", ".", "plot", "(", "256", ",", "ax", "=", "ax", ")", "intersections", "=", "curve1", ".", "evaluate_multi", "(", "s_vals", ")", "ax", ".", "plot", "(", "intersections", "[", "0", ",", ":", "]", ",", "intersections", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ",", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "0.0", ",", "0.75", ")", "ax", ".", "set_ylim", "(", "0.0", ",", "0.75", ")", "save_image", "(", "ax", ".", "figure", ",", "\"curve_intersect.png\"", ")" ]

[ "Image", "for", ":", "meth", ".", "Curve", ".", "intersect", "docstring", "." ]

[ "def", "surface_constructor", "(", "surface", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "surface", ".", "plot", "(", "256", ",", "with_nodes", "=", "True", ")", "line", "=", "ax", ".", "lines", "[", "0", "]", "nodes", "=", "surface", ".", "_nodes", "add_patch", "(", "ax", ",", "nodes", "[", ":", ",", "(", "0", ",", "1", ",", "2", ",", "5", ")", "]", ",", "line", ".", "get_color", "(", ")", ")", "delta", "=", "1.0", "/", "32.0", "ax", ".", "text", "(", "nodes", "[", "0", ",", "0", "]", ",", "nodes", "[", "1", ",", "0", "]", ",", "r\"$v_0$\"", ",", "fontsize", "=", "20", ",", "verticalalignment", "=", "\"top\"", ",", "horizontalalignment", "=", "\"right\"", ",", ")", "ax", ".", "text", "(", "nodes", "[", "0", ",", "1", "]", ",", "nodes", "[", "1", ",", "1", "]", ",", "r\"$v_1$\"", ",", "fontsize", "=", "20", ",", "verticalalignment", "=", "\"top\"", ",", "horizontalalignment", "=", "\"center\"", ",", ")", "ax", ".", "text", "(", "nodes", "[", "0", ",", "2", "]", ",", "nodes", "[", "1", ",", "2", "]", ",", "r\"$v_2$\"", ",", "fontsize", "=", "20", ",", "verticalalignment", "=", "\"top\"", ",", "horizontalalignment", "=", "\"left\"", ",", ")", "ax", ".", "text", "(", "nodes", "[", "0", ",", "3", "]", "-", "delta", ",", "nodes", "[", "1", ",", "3", "]", ",", "r\"$v_3$\"", ",", "fontsize", "=", "20", ",", "verticalalignment", "=", "\"center\"", ",", "horizontalalignment", "=", "\"right\"", ",", ")", "ax", ".", "text", "(", "nodes", "[", "0", ",", "4", "]", "+", "delta", ",", "nodes", "[", "1", ",", "4", "]", ",", "r\"$v_4$\"", ",", "fontsize", "=", "20", ",", "verticalalignment", "=", "\"center\"", ",", "horizontalalignment", "=", "\"left\"", ",", ")", "ax", ".", "text", "(", "nodes", "[", "0", ",", "5", "]", ",", "nodes", "[", "1", ",", "5", "]", "+", "delta", ",", "r\"$v_5$\"", ",", "fontsize", "=", "20", ",", "verticalalignment", "=", "\"bottom\"", ",", "horizontalalignment", "=", "\"center\"", ",", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.125", ",", "1.125", ")", "ax", ".", "set_ylim", "(", "-", "0.125", ",", "1.125", ")", "save_image", "(", "ax", ".", "figure", ",", "\"surface_constructor.png\"", ")" ]

[ "Image", "for", ":", "class", ".", "Surface", "docstring", "." ]

[ "def", "surface_evaluate_barycentric", "(", "surface", ",", "point", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "surface", ".", "plot", "(", "256", ")", "ax", ".", "plot", "(", "point", "[", "0", ",", ":", "]", ",", "point", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.125", ",", "1.125", ")", "ax", ".", "set_ylim", "(", "-", "0.125", ",", "1.125", ")", "save_image", "(", "ax", ".", "figure", ",", "\"surface_evaluate_barycentric.png\"", ")" ]

[ "Image", "for", ":", "meth", ".", "Surface", ".", "evaluate_barycentric", "docstring", "." ]

[ "def", "surface_evaluate_cartesian_multi", "(", "surface", ",", "points", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "surface", ".", "plot", "(", "256", ")", "ax", ".", "plot", "(", "points", "[", "0", ",", ":", "]", ",", "points", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ")", "delta", "=", "1.0", "/", "32.0", "font_size", "=", "18", "ax", ".", "text", "(", "points", "[", "0", ",", "0", "]", ",", "points", "[", "1", ",", "0", "]", ",", "r\"$w_0$\"", ",", "fontsize", "=", "font_size", ",", "verticalalignment", "=", "\"top\"", ",", "horizontalalignment", "=", "\"right\"", ",", ")", "ax", ".", "text", "(", "points", "[", "0", ",", "1", "]", "+", "2", "*", "delta", ",", "points", "[", "1", ",", "1", "]", ",", "r\"$w_1$\"", ",", "fontsize", "=", "font_size", ",", "verticalalignment", "=", "\"center\"", ",", "horizontalalignment", "=", "\"left\"", ",", ")", "ax", ".", "text", "(", "points", "[", "0", ",", "2", "]", ",", "points", "[", "1", ",", "2", "]", "+", "delta", ",", "r\"$w_2$\"", ",", "fontsize", "=", "font_size", ",", "verticalalignment", "=", "\"bottom\"", ",", "horizontalalignment", "=", "\"left\"", ",", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "3.125", ",", "2.375", ")", "ax", ".", "set_ylim", "(", "-", "0.25", ",", "2.125", ")", "save_image", "(", "ax", ".", "figure", ",", "\"surface_evaluate_cartesian_multi.png\"", ")" ]

[ "Image", "for", ":", "meth", ".", "Surface", ".", "evaluate_cartesian_multi", "docstring", "." ]

[ "def", "surface_is_valid1", "(", "surface", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "surface", ".", "plot", "(", "256", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.125", ",", "2.125", ")", "ax", ".", "set_ylim", "(", "-", "0.125", ",", "2.125", ")", "save_image", "(", "ax", ".", "figure", ",", "\"surface_is_valid1.png\"", ")" ]

[ "Image", "for", ":", "meth", ".", "Surface", ".", "is_valid", "docstring", "." ]

[ "def", "surface_is_valid3", "(", "surface", ")", ":", "if", "NO_IMAGES", ":", "return", "edge1", ",", "edge2", ",", "edge3", "=", "surface", ".", "edges", "N", "=", "128", "# Compute points on each edge.", "std_s", "=", "np", ".", "linspace", "(", "0.0", ",", "1.0", ",", "N", "+", "1", ")", "points1", "=", "edge1", ".", "evaluate_multi", "(", "std_s", ")", "points2", "=", "edge2", ".", "evaluate_multi", "(", "std_s", ")", "points3", "=", "edge3", ".", "evaluate_multi", "(", "std_s", ")", "# Compute the actual boundary where the Jacobian is 0.", "s_vals", "=", "np", ".", "linspace", "(", "0.0", ",", "0.2", ",", "N", ")", "t_discrim", "=", "np", ".", "sqrt", "(", "(", "1.0", "-", "s_vals", ")", "*", "(", "1.0", "-", "5.0", "*", "s_vals", ")", ")", "t_top", "=", "0.5", "*", "(", "1.0", "-", "s_vals", "+", "t_discrim", ")", "t_bottom", "=", "0.5", "*", "(", "1.0", "-", "s_vals", "-", "t_discrim", ")", "jacobian_zero_params", "=", "np", ".", "zeros", "(", "(", "2", "*", "N", "-", "1", ",", "2", ")", ",", "order", "=", "\"F\"", ")", "jacobian_zero_params", "[", ":", "N", ",", "0", "]", "=", "s_vals", "jacobian_zero_params", "[", ":", "N", ",", "1", "]", "=", "t_top", "jacobian_zero_params", "[", "N", ":", ",", "0", "]", "=", "s_vals", "[", "-", "2", ":", ":", "-", "1", "]", "jacobian_zero_params", "[", "N", ":", ",", "1", "]", "=", "t_bottom", "[", "-", "2", ":", ":", "-", "1", "]", "jac_edge", "=", "surface", ".", "evaluate_cartesian_multi", "(", "jacobian_zero_params", ")", "# Add the surface to the plot and add a dashed line", "# for each \"true\" edge.", "figure", "=", "plt", ".", "figure", "(", ")", "ax", "=", "figure", ".", "gca", "(", ")", "line", ",", "=", "ax", ".", "plot", "(", "jac_edge", "[", "0", ",", ":", "]", ",", "jac_edge", "[", "1", ",", ":", "]", ")", "color", "=", "line", ".", "get_color", "(", ")", "ax", ".", "plot", "(", "points1", "[", "0", ",", ":", "]", ",", "points1", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"dashed\"", ")", "ax", ".", "plot", "(", "points2", "[", "0", ",", ":", "]", ",", "points2", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"dashed\"", ")", "ax", ".", "plot", "(", "points3", "[", "0", ",", ":", "]", ",", "points3", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"dashed\"", ")", "polygon", "=", "np", ".", "hstack", "(", "[", "points1", "[", ":", ",", "1", ":", "]", ",", "points2", "[", ":", ",", "1", ":", "]", ",", "jac_edge", "[", ":", ",", "1", ":", "]", "]", ")", "add_patch", "(", "ax", ",", "polygon", ",", "color", ",", "with_nodes", "=", "False", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.0625", ",", "1.0625", ")", "ax", ".", "set_ylim", "(", "-", "0.0625", ",", "1.0625", ")", "save_image", "(", "ax", ".", "figure", ",", "\"surface_is_valid3.png\"", ")" ]

[ "Image", "for", ":", "meth", ".", "Surface", ".", "is_valid", "docstring", "." ]