def add_node_to_tree(nodes, n, nodes_to_import, name_remap, create_texts):
node_ref = nodes_to_import[n]
bl_idname = node_ref['bl_idname']
try:
if old_nodes.is_old(bl_idname):
old_nodes.register_old(bl_idname)
if bl_idname == 'SvMonadGenericNode':
node = unpack_monad(nodes, node_ref)
if not node:
raise Exception("It seems no valid node was created for this Monad {0}".format(node_ref))
else:
node = nodes.new(bl_idname)
except Exception as err:
exception(err)
error('%s not currently registered, skipping', bl_idname)
return
if create_texts:
add_texts(node, node_ref)
if hasattr(node, 'storage_set_data'):
node.storage_set_data(node_ref)
if bl_idname == 'SvObjectsNodeMK3':
for named_object in node_ref.get('object_names', []):
node.object_names.add().name = named_object
gather_remapped_names(node, n, name_remap)
apply_core_props(node, node_ref)
apply_superficial_props(node, node_ref)
apply_post_processing(node, node_ref)
apply_custom_socket_props(node, node_ref)
def execute(self, context):
if not self.preset_name:
msg = "Preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
path = get_preset_path(self.preset_name)
gist_filename = self.preset_name + ".json"
gist_description = self.preset_name
with open(path, 'rb') as jsonfile:
gist_body = jsonfile.read().decode('utf8')
try:
gist_url = sv_gist_tools.main_upload_function(gist_filename, gist_description, gist_body, show_browser=False)
context.window_manager.clipboard = gist_url # full destination url
info(gist_url)
self.report({'WARNING'}, "Copied gist URL to clipboad")
sv_gist_tools.write_or_append_datafiles(gist_url, gist_filename)
except Exception as err:
exception(err)
self.report({'ERROR'}, "Error 222: net connection or github login failed!")
return {'CANCELLED'}
finally:
return {'FINISHED'}
def execute(self, context):
ng = context.space_data.node_tree
gist_filename = ng.name
gist_description = 'to do later? 2018'
layout_dict = create_dict_of_tree(ng, skip_set={}, selected=self.selected_only)
try:
gist_body = json.dumps(layout_dict, sort_keys=True, indent=2)
except Exception as err:
if 'not JSON serializable' in repr(err):
error(layout_dict)
else:
exception(err)
self.report({'WARNING'}, "See terminal/Command prompt for printout of error")
return {'CANCELLED'}
try:
gist_url = sv_gist_tools.main_upload_function(gist_filename, gist_description, gist_body, show_browser=False)
context.window_manager.clipboard = gist_url # full destination url
info(gist_url)
self.report({'WARNING'}, "Copied gistURL to clipboad")
sv_gist_tools.write_or_append_datafiles(gist_url, gist_filename)
return {'FINISHED'}
except Exception as err:
info(err)
self.report({'ERROR'}, "Error 222: net connection or github login failed!")
return {'CANCELLED'}
def do_update_heat_map(node_list, nodes):
"""
Create a heat map for the node tree,
Needs development.
"""
if not nodes.id_data.sv_user_colors:
color_data = {node.name: (node.color[:], node.use_custom_color) for node in nodes}
nodes.id_data.sv_user_colors = str(color_data)
times = do_update_general(node_list, nodes)
if not times:
return
t_max = max(times)
addon_name = data_structure.SVERCHOK_NAME
addon = bpy.context.user_preferences.addons.get(addon_name)
if addon:
# to use Vector.lerp
cold = Vector(addon.preferences.heat_map_cold)
hot = addon.preferences.heat_map_hot
else:
error("Cannot find preferences")
cold = Vector((1, 1, 1))
hot = (.8, 0, 0)
for name, t in zip(node_list, times):
nodes[name].use_custom_color = True
# linear scale.
nodes[name].color = cold.lerp(hot, t / t_max)
def apply_socket_props(socket, info):
debug("applying socket props")
for tracked_prop_name, tracked_prop_value in info.items():
try:
setattr(socket, tracked_prop_name, tracked_prop_value)
except Exception as err:
error("Error while setting node socket: %s | %s", node.name, socket.index)
error("the following failed | %s <- %s", tracked_prop_name, tracked_prop_value)
exception(err)
def apply_custom_socket_props(node, node_ref):
debug("applying node props for node: %s", node.bl_idname)
socket_properties = node_ref.get('custom_socket_props')
if socket_properties:
for idx, info in socket_properties.items():
try:
socket = node.inputs[int(idx)]
apply_socket_props(socket, info)
except Exception as err:
error("socket index: %s, trying to pass: %s, num_sockets: %s", idx, info, len(node.inputs))
exception(err)
def make_update_list(node_tree, node_set=None, dependencies=None):
"""
Makes a update list from a node_group
if a node set is passed only the subtree defined by the node set is used. Otherwise
the complete node tree is used.
If dependencies are not passed they are built.
"""
ng = node_tree
if not node_set: # if no node_set, take all
node_set = set(ng.nodes.keys())
if len(node_set) == 1:
return list(node_set)
if node_set: # get one name
name = node_set.pop()
node_set.add(name)
else:
return []
if not dependencies:
deps = make_dep_dict(ng)
else:
deps = dependencies
tree_stack = collections.deque([name])
tree_stack_append = tree_stack.append
tree_stack_pop = tree_stack.pop
out = collections.OrderedDict()
# travel in node graph create one sorted list of nodes based on dependencies
node_count = len(node_set)
while node_count > len(out):
node_dependencies = True
for dep_name in deps[name]:
if dep_name in node_set and dep_name not in out:
tree_stack_append(name)
name = dep_name
node_dependencies = False
break
if len(tree_stack) > node_count:
error("Invalid node tree!")
return []
# if all dependencies are in out
if node_dependencies:
if name not in out:
out[name] = 1
if tree_stack:
name = tree_stack_pop()
else:
if node_count == len(out):
break
for node_name in node_set:
if node_name not in out:
name = node_name
break
return list(out.keys())
def compile_socket(link):
try:
link_data = (link.from_node.name, link.from_socket.index, link.to_node.name, link.to_socket.index)
except Exception as err:
if "'NodeSocketColor' object has no attribute 'index'" in repr(err):
debug('adding node reroute using socketname instead if index')
else:
error(repr(err))
link_data = (link.from_node.name, link.from_socket.name, link.to_node.name, link.to_socket.name)
return link_data
def display_introspection_info(node, k, v):
if not isinstance(v, (float, int, str)):
debug('//')
debug("%s -> property: %s: %s", node.name, k, type(v))
if k in node.bl_rna.properties:
debug(type(node.bl_rna.properties[k]))
elif k in node:
# something like node['lp'] , ID Property directly on the node instance.
debug(type(node[k]))
else:
error('%s is not bl_rna or IDproperty.. please report this', k)
debug('\\\\')
def update_cls(self):
"""
create or update the corresponding class reference
"""
if not all((self.input_node, self.output_node)):
error("Monad %s not set up correctly", self.name)
return None
cls_dict = {}
if not self.cls_bl_idname:
# the monad cls_bl_idname needs to be unique and cannot change
monad_base_name = make_valid_identifier(self.name)
monad_itentifier = id(self) ^ random.randint(0, 4294967296)
cls_name = "SvGroupNode{}_{}".format(monad_base_name, monad_itentifier)
# set the unique name for the class, depending on context this might fail
# then we cannot do the setup of the class properly so abandon
try:
self.cls_bl_idname = cls_name
except Exception:
return None
else:
cls_name = self.cls_bl_idname
self.verify_props()
cls_dict["bl_idname"] = cls_name
cls_dict["bl_label"] = self.name
cls_dict["input_template"] = self.generate_inputs()
cls_dict["output_template"] = self.generate_outputs()
self.make_props(cls_dict)
# done with setup
old_cls_ref = get_node_class_reference(cls_name)
bases = (SvGroupNodeExp, Node, SverchCustomTreeNode)
cls_ref = type(cls_name, bases, cls_dict)
if old_cls_ref:
sverchok.utils.unregister_node_class(old_cls_ref)
sverchok.utils.register_node_class(cls_ref)
return cls_ref
def frame_array(self, ts):
tangents, normals, binormals = self.tangent_normal_binormal_array(ts)
tangents = tangents / np.linalg.norm(tangents, axis=1)[np.newaxis].T
matrices_np = np.dstack((normals, binormals, tangents))
matrices_np = np.transpose(matrices_np, axes=(0,2,1))
try:
matrices_np = np.linalg.inv(matrices_np)
return matrices_np, normals, binormals
except np.linalg.LinAlgError as e:
error("Some of matrices are singular:")
for i, m in enumerate(matrices_np):
if abs(np.linalg.det(m) < 1e-5):
error("M[%s] (t = %s):\n%s", i, ts[i], m)
raise e
def execute(self, context):
ng = context.space_data.node_tree
is_tree_exportable, msg = self.can_be_exported(ng)
if not is_tree_exportable:
self.report({'ERROR'}, msg)
return {'CANCELLED'}
gist_filename = ng.name
app_version = bpy.app.version_string.replace(" ", "")
time_stamp = strftime("%Y.%m.%d | %H:%M", localtime())
gist_description = f"Sverchok.{version_and_sha} | Blender.{app_version} | {ng.name} | {time_stamp}"
# layout_dict = create_dict_of_tree(ng, skip_set={}, selected=self.selected_only)
if self.selected_only:
layout_dict = JSONExporter.get_nodes_structure([node for node in ng.nodes if node.select])
else:
layout_dict = JSONExporter.get_tree_structure(ng)
try:
gist_body = json.dumps(layout_dict, sort_keys=True, indent=2)
except Exception as err:
if 'not JSON serializable' in repr(err):
error(layout_dict)
exception(err)
self.report({'WARNING'}, "See terminal/Command prompt for printout of error")
return {'CANCELLED'}
try:
gist_url = sv_gist_tools.main_upload_function(gist_filename, gist_description, gist_body,
show_browser=False)
if not gist_url:
self.report({'ERROR'}, "You have not specified GitHub API access token, which is " +
"required to create gists from Sverchok. Please see " +
TOKEN_HELP_URL +
" for more information.")
return {'CANCELLED'}
context.window_manager.clipboard = gist_url # full destination url
info(gist_url)
self.report({'WARNING'}, "Copied gist URL to clipboad")
sv_gist_tools.write_or_append_datafiles(gist_url, gist_filename)
return {'FINISHED'}
except Exception as err:
exception(err)
self.report({'ERROR'}, "Error 222: net connection or github login failed!")
return {'CANCELLED'}
def update_cls(self):
"""
create or update the corresponding class reference
"""
if not all((self.input_node, self.output_node)):
error("Monad %s not set up correctly", self.name)
return None
cls_dict = {}
if not self.cls_bl_idname:
# the monad cls_bl_idname needs to be unique and cannot change
monad_base_name = make_valid_identifier(self.name)
monad_itentifier = id(self) ^ random.randint(0, 4294967296)
cls_name = "SvGroupNode{}_{}".format(monad_base_name, monad_itentifier)
# set the unique name for the class, depending on context this might fail
# then we cannot do the setup of the class properly so abandon
try:
self.cls_bl_idname = cls_name
except Exception:
return None
else:
cls_name = self.cls_bl_idname
self.verify_props()
cls_dict["bl_idname"] = cls_name
cls_dict["bl_label"] = self.name
cls_dict["input_template"] = self.generate_inputs()
cls_dict["output_template"] = self.generate_outputs()
self.make_props(cls_dict)
# done with setup
old_cls_ref = get_node_class_reference(cls_name)
bases = (SvGroupNodeExp, Node, SverchCustomTreeNode)
cls_ref = type(cls_name, bases, cls_dict)
if old_cls_ref:
sverchok.utils.unregister_node_class(old_cls_ref)
sverchok.utils.register_node_class(cls_ref)
return cls_ref
def execute(self, context):
if not self.preset_name:
msg = "Preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
path = get_preset_path(self.preset_name)
os.remove(path)
info("Removed `%s'", path)
self.report({'INFO'}, "Removed `{}'".format(self.preset_name))
return {'FINISHED'}
def compile_socket(link):
try:
link_data = (link.from_node.name, link.from_socket.index,
link.to_node.name, link.to_socket.index)
except Exception as err:
if "'NodeSocketColor' object has no attribute 'index'" in repr(err):
debug('adding node reroute using socketname instead if index')
else:
error(repr(err))
link_data = (link.from_node.name, link.from_socket.name,
link.to_node.name, link.to_socket.name)
return link_data
def execute(self, context):
if not self.preset_name:
msg = "Preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
path = get_preset_path(self.preset_name)
os.remove(path)
info("Removed `%s'", path)
self.report({'INFO'}, "Removed `{}'".format(self.preset_name))
return {'FINISHED'}
def unpack_monad(nodes, node_ref):
params = node_ref.get('params')
if params:
socket_prop_data = params.get('all_props')
monad_name = params.get('monad')
monad = bpy.data.node_groups[monad_name]
if socket_prop_data:
# including this to keep bw comp for trees that don't include this info.
monad.set_all_props(socket_prop_data)
cls_ref = monad.update_cls()
node = nodes.new(cls_ref.bl_idname)
# -- addition 1 --------- setting correct properties on sockets.
cls_dict = params.get('cls_dict')
input_template = cls_dict['input_template']
for idx, (sock_name, sock_type, sock_props) in enumerate(input_template):
socket_reference = node.inputs[idx]
if sock_props:
for prop, val in sock_props.items():
setattr(socket_reference, prop, val)
# -- addition 2 --------- force push param values
# -- (this step is skipped by apply_core_props because this node has a cls_dict)
for prop_data in ('float_props', 'int_props'):
data_list = socket_prop_data.get(prop_data)
if not data_list:
continue
for k, v in data_list.items():
if hasattr(node, k):
if k in params:
setattr(node, k, params[k])
# else:
# print(k, 'not in', params)
#else:
# print('node name:', node, node.name, 'has no property called', k, 'yet..')
# node.output_template = cls_dict['output_template']
for attr in 'vectorize', 'loop_me', 'loops_max', 'loops':
if attr in params:
setattr(node, attr, params[attr])
return node
else:
error('no parameters found! .json might be broken')
def check_dir(directory, fnames):
dir_name = basename(directory)
index_name = dir_name + "_index.rst"
index_file_path = join(directory, index_name)
bad_files = []
for fname in fnames:
if fname.endswith("_index.rst"):
continue
if not check(index_file_path, fname):
bad_files.append(fname)
if bad_files:
error("The following files are not mentioned in %s:\n%s",
index_name, "\n".join(bad_files))
self.fail(
"Not all node documentation files are mentioned in their corresponding indexes."
)
def make_links(update_lists, name_remap):
print_update_lists(update_lists)
failed_connections = []
for link in update_lists:
try:
ng.links.new(*resolve_socket(*link, name_dict=name_remap))
except Exception as err:
exception(err)
failed_connections.append(link)
continue
if failed_connections:
error("failed total: %s", len(failed_connections))
error(failed_connections)
else:
debug('no failed connections! awesome.')
def write_json(layout_dict, destination_path):
try:
m = json.dumps(layout_dict, sort_keys=True, indent=2)
except Exception as err:
error(repr(err))
info(layout_dict)
# optional post processing step
post_processing = False
if post_processing:
flatten = lambda match: r' {}'.format(match.group(1), m)
m = re.sub(r'\s\s+(\d+)', flatten, m)
with open(destination_path, 'w') as node_tree:
node_tree.writelines(m)
def check_dir(directory):
dir_name = basename(directory)
bad_files = []
for doc_path in glob(join(directory, "*.rst")):
if doc_path.endswith("_index.rst"):
continue
doc_file = basename(doc_path)
doc_name, ext = splitext(doc_file)
py_name = doc_name + ".py"
py_path = join(nodes_dir, dir_name, py_name)
if not exists(py_path):
bad_files.append(doc_file)
if bad_files:
error("Category %s: The following documentation files do not have respective python modules:\n%s", dir_name, "\n".join(bad_files))
self.fail("There are excessive documentation files.")
def write_json(layout_dict, destination_path):
try:
m = json.dumps(layout_dict, sort_keys=True, indent=2)
except Exception as err:
error(repr(err))
info(layout_dict)
# optional post processing step
post_processing = False
if post_processing:
flatten = lambda match: r' {}'.format(match.group(1), m)
m = re.sub(r'\s\s+(\d+)', flatten, m)
with open(destination_path, 'w') as node_tree:
node_tree.writelines(m)
def execute(self, context):
if not self.category:
msg = "Category name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
if self.category == GENERAL or self.category in get_category_names():
msg = "Category named `{}' already exists; refusing to overwrite existing category"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
path = get_presets_directory(category=self.category, mkdir=True)
info("Created new category `%s' at %s", self.category, path)
self.report({'INFO'}, "Created new category {}".format(self.category))
return {'FINISHED'}
def apply_core_props(node, node_ref):
params = node_ref['params']
if 'cls_dict' in params:
return
for p in params:
val = params[p]
try:
setattr(node, p, val)
except Exception as e:
# FIXME: this is ugly, need to find better approach
error_message = repr(e) # for reasons
error(error_message)
msg = 'failed to assign value to the node'
debug("`%s': %s = %s: %s", node.name, p, val, msg)
if "val: expected sequence items of type boolean, not int" in error_message:
debug("going to convert a list of ints to a list of bools and assign that instead")
setattr(node, p, [bool(i) for i in val])
def make_links(update_lists, name_remap):
print_update_lists(update_lists)
failed_connections = []
for link in update_lists:
try:
ng.links.new(*resolve_socket(*link, name_dict=name_remap))
except Exception as err:
exception(err)
failed_connections.append(link)
continue
if failed_connections:
error("failed total: %s", len(failed_connections))
error(failed_connections)
else:
debug('no failed connections! awesome.')
def apply_core_props(node, node_ref):
params = node_ref['params']
if 'cls_dict' in params:
return
for p in params:
val = params[p]
try:
setattr(node, p, val)
except Exception as e:
# FIXME: this is ugly, need to find better approach
error_message = repr(e) # for reasons
error(error_message)
msg = 'failed to assign value to the node'
debug("`%s': %s = %s: %s", node.name, p, val, msg)
if "val: expected sequence items of type boolean, not int" in error_message:
debug("going to convert a list of ints to a list of bools and assign that instead")
setattr(node, p, [bool(i) for i in val])
def execute(self, context):
bpy.ops.text.select_line()
bpy.ops.text.copy()
copied_text = bpy.data.window_managers[0].clipboard
if "def sv_main(" not in copied_text:
self.report({'INFO'}, "ERROR - LOOK CONSOLE")
error(sv_error_message)
return {'CANCELLED'}
answer = converted(copied_text)
if answer:
info(answer)
bpy.data.window_managers[0].clipboard = answer
bpy.ops.text.move(type='LINE_BEGIN')
bpy.ops.text.move(type='NEXT_LINE')
bpy.ops.text.paste()
return {'FINISHED'}
def unpack_monad(nodes, node_ref):
params = node_ref.get('params')
if params:
socket_prop_data = params.get('all_props')
monad_name = params.get('monad')
monad = bpy.data.node_groups[monad_name]
if socket_prop_data:
# including this to keep bw comp for trees that don't include this info.
monad.set_all_props(socket_prop_data)
cls_ref = monad.update_cls()
node = nodes.new(cls_ref.bl_idname)
# -- addition 1 --------- setting correct properties on sockets.
cls_dict = params.get('cls_dict')
input_template = cls_dict['input_template']
for idx, (sock_name, sock_type, sock_props) in enumerate(input_template):
socket_reference = node.inputs[idx]
if sock_props:
for prop, val in sock_props.items():
setattr(socket_reference, prop, val)
# -- addition 2 --------- force push param values
# -- (this step is skipped by apply_core_props because this node has a cls_dict)
for prop_data in ('float_props', 'int_props'):
data_list = socket_prop_data.get(prop_data)
if not data_list:
continue
for k, v in data_list.items():
if hasattr(node, k):
if k in params:
setattr(node, k, params[k])
# else:
# print(k, 'not in', params)
#else:
# print('node name:', node, node.name, 'has no property called', k, 'yet..')
# node.output_template = cls_dict['output_template']
return node
else:
error('no parameters found! .json might be broken')
def execute(self, context):
ng = context.space_data.node_tree
gist_filename = ng.name
gist_description = "Sverchok_" + version_and_sha + ng.name + "_Bl_" + bpy.app.version_string.replace(
" ", "") + str(tl().tm_year) + str(tl().tm_mon) + str(
tl().tm_mday) + str(tl().tm_hour)
layout_dict = create_dict_of_tree(ng,
skip_set={},
selected=self.selected_only)
try:
gist_body = json.dumps(layout_dict, sort_keys=True, indent=2)
except Exception as err:
if 'not JSON serializable' in repr(err):
error(layout_dict)
exception(err)
self.report({'WARNING'},
"See terminal/Command prompt for printout of error")
return {'CANCELLED'}
try:
gist_url = sv_gist_tools.main_upload_function(gist_filename,
gist_description,
gist_body,
show_browser=False)
if not gist_url:
self.report(
{'ERROR'},
"You have not specified GitHub API access token, which is "
+ "required to create gists from Sverchok. Please see " +
TOKEN_HELP_URL + " for more information.")
return {'CANCELLED'}
context.window_manager.clipboard = gist_url # full destination url
info(gist_url)
self.report({'WARNING'}, "Copied gist URL to clipboad")
sv_gist_tools.write_or_append_datafiles(gist_url, gist_filename)
return {'FINISHED'}
except Exception as err:
exception(err)
self.report({'ERROR'},
"Error 222: net connection or github login failed!")
return {'CANCELLED'}
def add_node_to_tree(nodes, n, nodes_to_import, name_remap, create_texts):
node_ref = nodes_to_import[n]
bl_idname = node_ref['bl_idname']
try:
if old_nodes.is_old(bl_idname):
old_nodes.register_old(bl_idname)
if bl_idname == 'SvMonadGenericNode':
node = unpack_monad(nodes, node_ref)
if not node:
raise Exception(
"It seems no valid node was created for this Monad {0}".
format(node_ref))
else:
if dummy_nodes.is_dependent(bl_idname):
try:
node = nodes.new(bl_idname)
except RuntimeError:
dummy_nodes.register_dummy(bl_idname)
node = nodes.new(bl_idname)
else:
node = nodes.new(bl_idname)
except Exception as err:
exception(err)
error('%s not currently registered, skipping', bl_idname)
return
# fix_enum_identifier_spaces_if_needed(node, node_ref)
if create_texts:
add_texts(node, node_ref)
if hasattr(node, 'storage_set_data'):
node.storage_set_data(node_ref)
if bl_idname == 'SvObjectsNodeMK3':
for named_object in node_ref.get('object_names', []):
node.object_names.add().name = named_object
gather_remapped_names(node, n, name_remap)
import_node_settings(node, node_ref)
def execute(self, context):
if not self.preset_name:
msg = "Preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
if not self.filepath:
msg = "Source file path is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
target_path = get_preset_path(self.preset_name)
shutil.copy(self.filepath, target_path)
msg = "Imported `{}' as `{}'".format(self.filepath, self.preset_name)
info(msg)
self.report({'INFO'}, msg)
return {'FINISHED'}
def execute(self, context):
if not self.preset_name:
msg = "Preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
if not self.filepath:
msg = "Target file path is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
existing_path = get_preset_path(self.preset_name, category=self.category)
shutil.copy(existing_path, self.filepath)
msg = "Saved `{} / {}' as `{}'".format(self.category, self.preset_name, self.filepath)
info(msg)
self.report({'INFO'}, msg)
return {'FINISHED'}
def frame_array(self, ts, on_zero_curvature=ASIS, tangent_delta=None):
"""
input:
* ts - np.array of shape (n,)
* on_zero_curvature - what to do if the curve has zero curvature at one of T values.
The supported options are:
* SvCurve.FAIL: raise ZeroCurvatureException
* SvCurve.RETURN_NONE: return None
* SvCurve.ASIS: do not perform special check for this case, the
algorithm will raise a general LinAlgError exception if it can't calculate the matrix.
output: tuple:
* matrices: np.array of shape (n, 3, 3)
* normals: np.array of shape (n, 3)
* binormals: np.array of shape (n, 3)
"""
h = self.get_tangent_delta(tangent_delta)
tangents, normals, binormals = self.tangent_normal_binormal_array(
ts, tangent_delta=h)
if on_zero_curvature != SvCurve.ASIS:
zero_normal = np.linalg.norm(normals, axis=1) < 1e-6
if zero_normal.any():
if on_zero_curvature == SvCurve.FAIL:
raise ZeroCurvatureException(np.unique(ts[zero_normal]),
zero_normal)
elif on_zero_curvature == SvCurve.RETURN_NONE:
return None
tangents = tangents / np.linalg.norm(tangents, axis=1)[np.newaxis].T
matrices_np = np.dstack((normals, binormals, tangents))
matrices_np = np.transpose(matrices_np, axes=(0, 2, 1))
try:
matrices_np = np.linalg.inv(matrices_np)
return matrices_np, normals, binormals
except np.linalg.LinAlgError as e:
error("Some of matrices are singular:")
for i, m in enumerate(matrices_np):
if abs(np.linalg.det(m) < 1e-5):
error("M[%s] (t = %s):\n%s", i, ts[i], m)
raise e
def execute(self, context):
if not self.category:
msg = "Preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
if self.category == GENERAL:
msg = "General category can not be deleted"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
path = get_presets_directory(category=self.category)
files = glob(join(path, "*"))
if files:
msg = "Category `{}' is not empty; refusing to delete non-empty category.".format(
self.category)
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
os.rmdir(path)
ntree = context.space_data.node_tree
panel_props = ntree.preset_panel_properties
panel_props.category = GENERAL
return {'FINISHED'}
def execute(self, context):
if not self.preset_name:
msg = "Preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
if not self.gist_id:
msg = "Gist ID is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
gist_data = sv_IO_panel_tools.load_json_from_gist(self.gist_id, self)
target_path = get_preset_path(self.preset_name)
if os.path.exists(target_path):
msg = "Preset named `{}' already exists. Refusing to rewrite existing preset.".format(self.preset_name)
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
with open(target_path, 'wb') as jsonfile:
gist_data = json.dumps(gist_data, sort_keys=True, indent=2).encode('utf8')
jsonfile.write(gist_data)
msg = "Imported `{}' as `{}'".format(self.gist_id, self.preset_name)
info(msg)
self.report({'INFO'}, msg)
return {'FINISHED'}
def execute(self, context):
if not self.id_tree:
msg = "Node tree is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
if not self.preset_name:
msg = "Preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
ng = bpy.data.node_groups[self.id_tree]
nodes = list(filter(lambda n: n.select, ng.nodes))
if not len(nodes):
msg = "There are no selected nodes to export"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
layout_dict = JSONExporter.get_nodes_structure([n for n in ng.nodes if n.select])
preset = SvPreset(name=self.preset_name, category = self.category)
preset.make_add_operator()
destination_path = preset.path
json.dump(layout_dict, open(destination_path, 'w'), sort_keys=True, indent=2)
msg = 'exported to: ' + destination_path
self.report({"INFO"}, msg)
info(msg)
return {'FINISHED'}
def execute(self, context):
if not self.id_tree:
msg = "Node tree is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
if not self.preset_name:
msg = "Preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
ng = bpy.data.node_groups[self.id_tree]
nodes = list(filter(lambda n: n.select, ng.nodes))
if not len(nodes):
msg = "There are no selected nodes to export"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
layout_dict = create_dict_of_tree(ng, selected=True)
preset = SvPreset(name=self.preset_name)
preset.make_add_operator()
destination_path = preset.path
write_json(layout_dict, destination_path)
msg = 'exported to: ' + destination_path
self.report({"INFO"}, msg)
info(msg)
return {'FINISHED'}
def register_old(bl_id):
if bl_id in old_bl_idnames:
mod = importlib.import_module(".{}".format(old_bl_idnames[bl_id]), __name__)
res = inspect.getmembers(mod)
# print('mod/res:', mod, res)
for name, cls in res:
if inspect.isclass(cls):
if issubclass(cls, bpy.types.Node) and cls.bl_idname == bl_id:
if bl_id not in imported_mods:
try:
mod.register()
except Exception as err:
print('failed mod register')
exception(err)
imported_mods[bl_id] = mod
return mod
else:
return imported_mods[bl_id]
error("Cannot find {} among old nodes".format(bl_id))
return None
def get_file_obj_from_zip(fullpath):
'''
fullpath must point to a zip file.
usage:
nodes_json = get_file_obj_from_zip(fullpath)
print(nodes_json['export_version'])
'''
with zipfile.ZipFile(fullpath, "r") as jfile:
exported_name = ""
for name in jfile.namelist():
if name.endswith('.json'):
exported_name = name
break
if not exported_name:
error('zip contains no files ending with .json')
return
debug(exported_name + ' <')
fp = jfile.open(exported_name, 'r')
m = fp.read().decode()
return json.loads(m)
def read_n_decode(url):
try:
content_at_url = urlopen(url)
found_json = content_at_url.read().decode()
return found_json
except urllib.error.HTTPError as err:
if err.code == 404:
message = 'url: ' + str(url) + ' doesn\'t appear to be a valid url, copy it again from your source'
error(message)
if operator:
operator.report({'ERROR'}, message)
else:
message = 'url error:' + str(err.code)
error(message)
if operator:
operator.report({'ERROR'}, message)
except Exception as err:
exception(err)
if operator:
operator.report({'ERROR'}, 'unspecified error, check your internet connection')
return
def read_n_decode(url):
try:
content_at_url = urlopen(url)
found_json = content_at_url.read().decode()
return found_json
except urllib.error.HTTPError as err:
if err.code == 404:
message = 'url: ' + str(url) + ' doesn\'t appear to be a valid url, copy it again from your source'
error(message)
if operator:
operator.report({'ERROR'}, message)
else:
message = 'url error:' + str(err.code)
error(message)
if operator:
operator.report({'ERROR'}, message)
except Exception as err:
exception(err)
if operator:
operator.report({'ERROR'}, 'unspecified error, check your internet connection')
return
def register_old(bl_id):
if bl_id in old_bl_idnames:
mod = importlib.import_module(".{}".format(old_bl_idnames[bl_id]), __name__)
res = inspect.getmembers(mod)
# print('mod/res:', mod, res)
for name, cls in res:
if inspect.isclass(cls):
if issubclass(cls, bpy.types.Node) and cls.bl_idname == bl_id:
if bl_id not in imported_mods:
try:
mod.register()
except Exception as err:
print('failed mod register')
exception(err)
imported_mods[bl_id] = mod
return mod
else:
return imported_mods[bl_id]
error("Cannot find {} among old nodes".format(bl_id))
return None
def get_file_obj_from_zip(fullpath):
'''
fullpath must point to a zip file.
usage:
nodes_json = get_file_obj_from_zip(fullpath)
print(nodes_json['export_version'])
'''
with zipfile.ZipFile(fullpath, "r") as jfile:
exported_name = ""
for name in jfile.namelist():
if name.endswith('.json'):
exported_name = name
break
if not exported_name:
error('zip contains no files ending with .json')
return
debug(exported_name + ' <')
fp = jfile.open(exported_name, 'r')
m = fp.read().decode()
return json.loads(m)
def execute(self, context):
ng = context.space_data.node_tree
gist_filename = ng.name
gist_description = 'to do later? 2018'
layout_dict = create_dict_of_tree(ng,
skip_set={},
selected=self.selected_only)
try:
gist_body = json.dumps(layout_dict, sort_keys=True, indent=2)
except Exception as err:
if 'not JSON serializable' in repr(err):
error(layout_dict)
else:
exception(err)
self.report({'WARNING'},
"See terminal/Command prompt for printout of error")
return {'CANCELLED'}
try:
gist_url = sv_gist_tools.main_upload_function(gist_filename,
gist_description,
gist_body,
show_browser=False)
context.window_manager.clipboard = gist_url # full destination url
info(gist_url)
self.report({'WARNING'}, "Copied gistURL to clipboad")
sv_gist_tools.write_or_append_datafiles(gist_url, gist_filename)
return {'FINISHED'}
except Exception as err:
info(err)
self.report(
{'ERROR'},
"Error uploading the gist, check your internet connection!")
return {'CANCELLED'}
def add_node_to_tree(nodes, n, nodes_to_import, name_remap, create_texts):
node_ref = nodes_to_import[n]
bl_idname = node_ref['bl_idname']
try:
if old_nodes.is_old(bl_idname):
old_nodes.register_old(bl_idname)
if bl_idname == 'SvMonadGenericNode':
node = unpack_monad(nodes, node_ref)
if not node:
raise Exception(
"It seems no valid node was created for this Monad {0}".
format(node_ref))
else:
node = nodes.new(bl_idname)
except Exception as err:
exception(err)
error('%s not currently registered, skipping', bl_idname)
return
if create_texts:
add_texts(node, node_ref)
if hasattr(node, 'storage_set_data'):
node.storage_set_data(node_ref)
if bl_idname == 'SvObjectsNodeMK3':
for named_object in node_ref.get('object_names', []):
node.object_names.add().name = named_object
gather_remapped_names(node, n, name_remap)
apply_core_props(node, node_ref)
apply_superficial_props(node, node_ref)
apply_post_processing(node, node_ref)
apply_custom_socket_props(node, node_ref)
def check_category(directory):
dir_name = basename(directory)
bad_files = []
known = []
for module_path in glob(join(directory, "*.py")):
module_file = basename(module_path)
if module_file == "__init__.py":
continue
module_name, ext = splitext(module_file)
doc_name = module_name + ".rst"
doc_path = join(docs_dir, dir_name, doc_name)
if not exists(doc_path):
if module_file in known_problems:
known.append(module_file)
else:
bad_files.append(module_file)
if known:
info("Category %s: Tolerating unexistance of the documentation for the following nodes for now:\n%s", dir_name, "\n".join(known))
if bad_files:
error("Category %s: The following nodes do not have corresponding documentation files:\n%s", dir_name, "\n".join(bad_files))
self.fail("Not all nodes have corresponding documentation; missing are:\n{}".format("\n".join(bad_files)))
def execute(self, context):
if not self.old_name:
msg = "Old preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
if not self.new_name:
msg = "New preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
preset = SvPreset(name=self.old_name, category=self.old_category)
preset.meta['description'] = self.description
preset.meta['keywords'] = self.keywords
preset.meta['author'] = self.author
preset.meta['license'] = self.license
preset.save()
category_changed = self.allow_change_category and (self.new_category !=
self.old_category)
if self.new_name != self.old_name or category_changed:
old_path = get_preset_path(self.old_name,
category=self.old_category)
new_path = get_preset_path(self.new_name,
category=self.new_category)
if os.path.exists(new_path):
msg = "Preset named `{}' already exists. Refusing to rewrite existing preset.".format(
self.new_name)
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
os.rename(old_path, new_path)
preset.name = self.new_name
preset.category = self.new_category
info("Renamed `%s' to `%s'", old_path, new_path)
self.report({'INFO'},
"Renamed `{}' to `{}'".format(self.old_name,
self.new_name))
bpy.utils.unregister_class(preset_add_operators[(self.old_category,
self.old_name)])
del preset_add_operators[(self.old_category, self.old_name)]
preset.make_add_operator()
return {'FINISHED'}
def execute(self, context):
if not self.old_name:
msg = "Old preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
if not self.new_name:
msg = "New preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
preset = SvPreset(name = self.old_name)
preset.meta['description'] = self.description
preset.meta['author'] = self.author
preset.meta['license'] = self.license
preset.save()
if self.new_name != self.old_name:
old_path = get_preset_path(self.old_name)
new_path = get_preset_path(self.new_name)
if os.path.exists(new_path):
msg = "Preset named `{}' already exists. Refusing to rewrite existing preset.".format(self.new_name)
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
os.rename(old_path, new_path)
preset.name = self.new_name
info("Renamed `%s' to `%s'", old_path, new_path)
self.report({'INFO'}, "Renamed `{}' to `{}'".format(self.old_name, self.new_name))
bpy.utils.unregister_class(preset_add_operators[self.old_name])
del preset_add_operators[self.old_name]
preset.make_add_operator()
return {'FINISHED'}
def execute(self, context):
if not self.id_tree:
msg = "Node tree is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
if not self.preset_name:
msg = "Preset name is not specified"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
ng = bpy.data.node_groups[self.id_tree]
nodes = list(filter(lambda n: n.select, ng.nodes))
if not len(nodes):
msg = "There are no selected nodes to export"
error(msg)
self.report({'ERROR'}, msg)
return {'CANCELLED'}
# the operator can be used for both preset importing of a node and preset from a bunch of selected nodes
if self.is_node_preset:
layout_dict = JSONExporter.get_node_structure(nodes[0])
else:
layout_dict = JSONExporter.get_tree_structure(ng, True)
preset = SvPreset(name=self.preset_name, category=self.category)
preset.make_add_operator()
destination_path = preset.path
json.dump(layout_dict, open(destination_path, 'w'),
indent=2) # sort keys is not expected by the exporter
msg = 'exported to: ' + destination_path
self.report({"INFO"}, msg)
info(msg)
return {'FINISHED'}
def test_get_data_nesting_level_2(self):
with self.assertRaises(TypeError):
data = [dict(), 3]
level = get_data_nesting_level(data)
error("get_data_nesting_level() returned %s", level)
def test_ensure_nesting_level_2(self):
with self.assertRaises(TypeError):
data = [[[17]]]
result = ensure_nesting_level(data, 1)
error("ensure_nesting_level() returned %s", result)
def create_dict_of_tree(ng, skip_set={}, selected=False, identified_node=None):
nodes = ng.nodes
layout_dict = {}
nodes_dict = {}
groups_dict = {}
if not skip_set:
skip_set = {'Sv3DviewPropsNode'}
if selected:
nodes = list(filter(lambda n: n.select, nodes))
if identified_node:
# this mode will import one node only.
nodes = [identified_node]
# get nodes and params
for node in nodes:
if node.bl_idname in skip_set:
continue
node_dict = {}
node_items = {}
node_enums = find_enumerators(node)
IsMonadInstanceNode = (node.bl_idname.startswith('SvGroupNodeMonad'))
for k, v in node.items():
display_introspection_info(node, k, v)
if can_skip_property(node, k):
continue
elif has_state_switch_protection(node, k):
continue
handle_old_groupnode(node, k, v, groups_dict, create_dict_of_tree)
if isinstance(v, (float, int, str)):
node_items[k] = v
elif node.bl_idname in {'ScalarMathNode', 'SvLogicNode'} and k == 'prop_types':
node_items[k] = getattr(node, k)[:]
continue
else:
node_items[k] = v[:]
handle_enum_property(node, k, v, node_items, node_enums)
if IsMonadInstanceNode and node.monad:
pack_monad(node, node_items, groups_dict, create_dict_of_tree)
if hasattr(node, "storage_get_data"):
node.storage_get_data(node_dict)
node_dict['params'] = node_items
collect_custom_socket_properties(node, node_dict)
# if node.bl_idname == 'NodeFrame':
# frame_props = 'shrink', 'use_custom_color', 'label_size'
# node_dict['params'].update({fpv: getattr(node, fpv) for fpv in frame_props})
if IsMonadInstanceNode:
node_dict['bl_idname'] = 'SvMonadGenericNode'
else:
node_dict['bl_idname'] = node.bl_idname
if node.bl_idname in {'SvGroupInputsNodeExp', 'SvGroupOutputsNodeExp'}:
node_dict[node.node_kind] = node.stash()
get_superficial_props(node_dict, node)
nodes_dict[node.name] = node_dict
# -------------------
layout_dict['nodes'] = nodes_dict
layout_dict['groups'] = groups_dict
# ''' get connections '''
# links = (compile_socket(l) for l in ng.links)
# connections_dict = {idx: link for idx, link in enumerate(links)}
# layout_dict['connections'] = connections_dict
''' get framed nodes '''
framed_nodes = {}
for node in nodes:
if node.bl_idname in skip_set:
continue
if node.parent:
if selected and node.parent.select:
framed_nodes[node.name] = node.parent.name
elif not selected:
framed_nodes[node.name] = node.parent.name
layout_dict['framed_nodes'] = framed_nodes
''' get update list (cache, order to link) '''
# try/except for now, node tree links might be invalid
# among other things. auto rebuild on F8
try:
ng.build_update_list()
links_out = []
for name in chain(*ng.get_update_lists()[0]):
for socket in ng.nodes[name].inputs:
if selected and not ng.nodes[name].select:
continue
if socket.links:
link = socket.links[0]
if selected and not link.from_node.select:
continue
links_out.append(compile_socket(link))
layout_dict['update_lists'] = links_out
except Exception as err:
exception(err)
error('no update lists found or other error!')
error(' - trigger an update and retry')
return
layout_dict['export_version'] = _EXPORTER_REVISION_
return layout_dict