# ***** BEGIN GPL LICENSE BLOCK *****
#
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ***** END GPL LICENCE BLOCK *****
#
# -----------------------------------------------------------------------
# Author: Alan Odom (Clockmender), Rune Morling (ermo) Copyright (c) 2019
# -----------------------------------------------------------------------
#
import bmesh
import numpy as np
from math import sqrt, tan, pi
from mathutils import Vector
from mathutils.geometry import intersect_point_line
from .pdt_functions import (
set_mode,
oops,
get_percent,
dis_ang,
check_selection,
arc_centre,
intersection,
view_coords_i,
view_coords,
view_dir,
set_axis,
)
from . import pdt_exception
PDT_SelectionError = pdt_exception.SelectionError
PDT_InvalidVector = pdt_exception.InvalidVector
PDT_ObjectModeError = pdt_exception.ObjectModeError
PDT_InfRadius = pdt_exception.InfRadius
PDT_NoObjectError = pdt_exception.NoObjectError
PDT_IntersectionError = pdt_exception.IntersectionError
PDT_InvalidOperation = pdt_exception.InvalidOperation
PDT_VerticesConnected = pdt_exception.VerticesConnected
PDT_InvalidAngle = pdt_exception.InvalidAngle
from .pdt_msg_strings import (
PDT_ERR_BAD3VALS,
PDT_ERR_BAD2VALS,
PDT_ERR_BAD1VALS,
PDT_ERR_CONNECTED,
PDT_ERR_SEL_2_VERTS,
PDT_ERR_EDOB_MODE,
PDT_ERR_NO_ACT_OBJ,
PDT_ERR_VERT_MODE,
PDT_ERR_SEL_3_VERTS,
PDT_ERR_SEL_3_OBJS,
PDT_ERR_EDIT_MODE,
PDT_ERR_NON_VALID,
PDT_LAB_NOR,
PDT_ERR_STRIGHT_LINE,
PDT_LAB_ARCCENTRE,
PDT_ERR_SEL_4_VERTS,
PDT_ERR_INT_NO_ALL,
PDT_LAB_INTERSECT,
PDT_ERR_SEL_4_OBJS,
PDT_INF_OBJ_MOVED,
PDT_ERR_SEL_2_VERTIO,
PDT_ERR_SEL_2_OBJS,
PDT_ERR_SEL_3_VERTIO,
PDT_ERR_TAPER_ANG,
PDT_ERR_TAPER_SEL,
PDT_ERR_INT_LINES,
PDT_LAB_PLANE,
)
def vector_build(context, pg, obj, operation, values, num_values):
"""Build Movement Vector from input Fields.
Args:
context: Blender bpy.context instance.
pg: PDT Parameters Group - our variables
obj: The Active Object
operation: The Operation e.g. Create New Vertex
values: The paramters passed e.g. 1,4,3 for Catrtesan Coordinates
num_values: The number of values passed - determines the function
Returns:
Vector to position, or offset items.
"""
scene = context.scene
plane = pg.plane
flip_angle = pg.flip_angle
flip_percent= pg.flip_percent
# Cartesian 3D coordinates
if num_values == 3 and len(values) == 3:
output_vector = Vector((float(values[0]), float(values[1]), float(values[2])))
# Polar 2D coordinates
elif num_values == 2 and len(values) == 2:
output_vector = dis_ang(values, flip_angle, plane, scene)
# Percentage of imaginary line between two 3D coordinates
elif num_values == 1 and len(values) == 1:
output_vector = get_percent(obj, flip_percent, float(values[0]), operation, scene)
else:
if num_values == 3:
pg.error = PDT_ERR_BAD3VALS
elif num_values == 2:
pg.error = PDT_ERR_BAD2VALS
else:
pg.error = PDT_ERR_BAD1VALS
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_InvalidVector
return output_vector
def placement_normal(context, operation):
"""Manipulates Geometry, or Objects by Normal Intersection between 3 points.
Args:
context: Blender bpy.context instance.
operation: The Operation e.g. Create New Vertex
Returns:
Status Set.
"""
scene = context.scene
pg = scene.pdt_pg
extend_all = pg.extend
obj = context.view_layer.objects.active
if obj.mode == "EDIT":
if obj is None:
pg.error = PDT_ERR_NO_ACT_OBJ
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_ObjectModeError
obj_loc = obj.matrix_world.decompose()[0]
bm = bmesh.from_edit_mesh(obj.data)
if len(bm.select_history) == 3:
vector_a, vector_b, vector_c = check_selection(3, bm, obj)
if vector_a is None:
pg.error = PDT_ERR_VERT_MODE
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_InvalidVector
else:
pg.error = f"{PDT_ERR_SEL_3_VERTIO} {len(bm.select_history)})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
elif obj.mode == "OBJECT":
objs = context.view_layer.objects.selected
if len(objs) != 3:
pg.error = f"{PDT_ERR_SEL_3_OBJS} {len(objs)})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
objs_s = [ob for ob in objs if ob.name != obj.name]
vector_a = obj.matrix_world.decompose()[0]
vector_b = objs_s[-1].matrix_world.decompose()[0]
vector_c = objs_s[-2].matrix_world.decompose()[0]
vector_delta = intersect_point_line(vector_a, vector_b, vector_c)[0]
if operation == "C":
if obj.mode == "EDIT":
scene.cursor.location = obj_loc + vector_delta
elif obj.mode == "OBJECT":
scene.cursor.location = vector_delta
elif operation == "P":
if obj.mode == "EDIT":
pg.pivot_loc = obj_loc + vector_delta
elif obj.mode == "OBJECT":
pg.pivot_loc = vector_delta
elif operation == "G":
if obj.mode == "EDIT":
if extend_all:
for v in [v for v in bm.verts if v.select]:
v.co = vector_delta
bm.select_history.clear()
bmesh.ops.remove_doubles(bm, verts=[v for v in bm.verts if v.select], dist=0.0001)
else:
bm.select_history[-1].co = vector_delta
bm.select_history.clear()
bmesh.update_edit_mesh(obj.data)
elif obj.mode == "OBJECT":
context.view_layer.objects.active.location = vector_delta
elif operation == "N":
if obj.mode == "EDIT":
vertex_new = bm.verts.new(vector_delta)
bmesh.update_edit_mesh(obj.data)
bm.select_history.clear()
for v in [v for v in bm.verts if v.select]:
v.select_set(False)
vertex_new.select_set(True)
else:
pg.error = f"{PDT_ERR_EDIT_MODE} {obj.mode})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
return
elif operation == "V" and obj.mode == "EDIT":
vector_new = vector_delta
vertex_new = bm.verts.new(vector_new)
if extend_all:
for v in [v for v in bm.verts if v.select]:
bm.edges.new([v, vertex_new])
else:
bm.edges.new([bm.select_history[-1], vertex_new])
for v in [v for v in bm.verts if v.select]:
v.select_set(False)
vertex_new.select_set(True)
bmesh.update_edit_mesh(obj.data)
bm.select_history.clear()
else:
pg.error = f"{operation} {PDT_ERR_NON_VALID} {PDT_LAB_NOR}"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
def placement_arc_centre(context, operation):
"""Manipulates Geometry, or Objects to an Arc Centre defined by 3 points on an Imaginary Arc.
Args:
context: Blender bpy.context instance.
operation: The Operation e.g. Create New Vertex
Returns:
Status Set.
"""
scene = context.scene
pg = scene.pdt_pg
extend_all = pg.extend
obj = context.view_layer.objects.active
if obj.mode == "EDIT":
if obj is None:
pg.error = PDT_ERR_NO_ACT_OBJ
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_ObjectModeError
obj = context.view_layer.objects.active
obj_loc = obj.matrix_world.decompose()[0]
bm = bmesh.from_edit_mesh(obj.data)
verts = [v for v in bm.verts if v.select]
if len(verts) != 3:
pg.error = f"{PDT_ERR_SEL_3_VERTS} {len(verts)})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
vector_a = verts[0].co
vector_b = verts[1].co
vector_c = verts[2].co
vector_delta, radius = arc_centre(vector_a, vector_b, vector_c)
if str(radius) == "inf":
pg.error = PDT_ERR_STRIGHT_LINE
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_InfRadius
pg.distance = radius
if operation == "C":
scene.cursor.location = obj_loc + vector_delta
elif operation == "P":
pg.pivot_loc = obj_loc + vector_delta
elif operation == "N":
vector_new = vector_delta
vertex_new = bm.verts.new(vector_new)
for v in [v for v in bm.verts if v.select]:
v.select_set(False)
vertex_new.select_set(True)
bmesh.update_edit_mesh(obj.data)
bm.select_history.clear()
vertex_new.select_set(True)
elif operation == "G":
if extend_all:
for v in [v for v in bm.verts if v.select]:
v.co = vector_delta
bm.select_history.clear()
bmesh.ops.remove_doubles(bm, verts=[v for v in bm.verts if v.select], dist=0.0001)
else:
bm.select_history[-1].co = vector_delta
bm.select_history.clear()
bmesh.update_edit_mesh(obj.data)
elif operation == "V":
vertex_new = bm.verts.new(vector_delta)
if extend_all:
for v in [v for v in bm.verts if v.select]:
bm.edges.new([v, vertex_new])
v.select_set(False)
vertex_new.select_set(True)
bm.select_history.clear()
bmesh.ops.remove_doubles(bm, verts=[v for v in bm.verts if v.select], dist=0.0001)
bmesh.update_edit_mesh(obj.data)
else:
bm.edges.new([bm.select_history[-1], vertex_new])
bmesh.update_edit_mesh(obj.data)
bm.select_history.clear()
else:
pg.error = f"{operation} {PDT_ERR_NON_VALID} {PDT_LAB_ARCCENTRE}"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
elif obj.mode == "OBJECT":
if len(context.view_layer.objects.selected) != 3:
pg.error = f"{PDT_ERR_SEL_3_OBJS} {len(context.view_layer.objects.selected)})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
vector_a = context.view_layer.objects.selected[0].matrix_world.decompose()[0]
vector_b = context.view_layer.objects.selected[1].matrix_world.decompose()[0]
vector_c = context.view_layer.objects.selected[2].matrix_world.decompose()[0]
vector_delta, radius = arc_centre(vector_a, vector_b, vector_c)
pg.distance = radius
if operation == "C":
scene.cursor.location = vector_delta
elif operation == "P":
pg.pivot_loc = vector_delta
elif operation == "G":
context.view_layer.objects.active.location = vector_delta
else:
pg.error = f"{operation} {PDT_ERR_NON_VALID} {PDT_LAB_ARCCENTRE}"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
def placement_intersect(context, operation):
"""Manipulates Geometry, or Objects by Convergance Intersection between 4 points, or 2 Edges.
Args:
context: Blender bpy.context instance.
operation: The Operation e.g. Create New Vertex
Returns:
Status Set.
"""
scene = context.scene
pg = scene.pdt_pg
plane = pg.plane
obj = context.view_layer.objects.active
if obj.mode == "EDIT":
if obj is None:
pg.error = PDT_ERR_NO_ACT_OBJ
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_NoObjectError
obj_loc = obj.matrix_world.decompose()[0]
bm = bmesh.from_edit_mesh(obj.data)
edges = [e for e in bm.edges if e.select]
extend_all = pg.extend
if len(edges) == 2:
vertex_a = edges[0].verts[0]
vertex_b = edges[0].verts[1]
vertex_c = edges[1].verts[0]
vertex_d = edges[1].verts[1]
else:
if len(bm.select_history) != 4:
pg.error = (
PDT_ERR_SEL_4_VERTS
+ str(len(bm.select_history))
+ " Vertices/"
+ str(len(edges))
+ " Edges)"
)
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
vertex_a = bm.select_history[-1]
vertex_b = bm.select_history[-2]
vertex_c = bm.select_history[-3]
vertex_d = bm.select_history[-4]
vector_delta, done = intersection(vertex_a.co, vertex_b.co, vertex_c.co, vertex_d.co, plane)
if not done:
pg.error = f"{PDT_ERR_INT_LINES} {plane} {PDT_LAB_PLANE}"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_IntersectionError
if operation == "C":
scene.cursor.location = obj_loc + vector_delta
elif operation == "P":
pg.pivot_loc = obj_loc + vector_delta
elif operation == "N":
vector_new = vector_delta
vertex_new = bm.verts.new(vector_new)
for v in [v for v in bm.verts if v.select]:
v.select_set(False)
for f in bm.faces:
f.select_set(False)
for e in bm.edges:
e.select_set(False)
vertex_new.select_set(True)
bmesh.update_edit_mesh(obj.data)
bm.select_history.clear()
elif operation in {"G", "V"}:
vertex_new = None
process = False
if (vertex_a.co - vector_delta).length < (vertex_b.co - vector_delta).length:
if operation == "G":
vertex_a.co = vector_delta
process = True
else:
vertex_new = bm.verts.new(vector_delta)
bm.edges.new([vertex_a, vertex_new])
process = True
else:
if operation == "G" and extend_all:
vertex_b.co = vector_delta
elif operation == "V" and extend_all:
vertex_new = bm.verts.new(vector_delta)
bm.edges.new([vertex_b, vertex_new])
else:
return
if (vertex_c.co - vector_delta).length < (vertex_d.co - vector_delta).length:
if operation == "G" and extend_all:
vertex_c.co = vector_delta
elif operation == "V" and extend_all:
bm.edges.new([vertex_c, vertex_new])
else:
return
else:
if operation == "G" and extend_all:
vertex_d.co = vector_delta
elif operation == "V" and extend_all:
bm.edges.new([vertex_d, vertex_new])
else:
return
bm.select_history.clear()
bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.0001)
if not process and not extend_all:
pg.error = PDT_ERR_INT_NO_ALL
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
bmesh.update_edit_mesh(obj.data)
return
for v in bm.verts:
v.select_set(False)
for f in bm.faces:
f.select_set(False)
for e in bm.edges:
e.select_set(False)
if vertex_new is not None:
vertex_new.select_set(True)
for v in bm.select_history:
if v is not None:
v.select_set(True)
bmesh.update_edit_mesh(obj.data)
else:
pg.error = f"{operation} {PDT_ERR_NON_VALID} {PDT_LAB_INTERSECT}"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_InvalidOperation
elif obj.mode == "OBJECT":
if len(context.view_layer.objects.selected) != 4:
pg.error = f"{PDT_ERR_SEL_4_OBJS} {len(context.view_layer.objects.selected)})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
order = pg.object_order.split(",")
objs = sorted(context.view_layer.objects.selected, key=lambda x: x.name)
pg.error = (
"Original Object Order (1,2,3,4) was: "
+ objs[0].name
+ ", "
+ objs[1].name
+ ", "
+ objs[2].name
+ ", "
+ objs[3].name
)
context.window_manager.popup_menu(oops, title="Info", icon="INFO")
vector_a = objs[int(order[0]) - 1].matrix_world.decompose()[0]
vector_b = objs[int(order[1]) - 1].matrix_world.decompose()[0]
vector_c = objs[int(order[2]) - 1].matrix_world.decompose()[0]
vector_d = objs[int(order[3]) - 1].matrix_world.decompose()[0]
vector_delta, done = intersection(vector_a, vector_b, vector_c, vector_d, plane)
if not done:
pg.error = f"{PDT_ERR_INT_LINES} {plane} {PDT_LAB_PLANE}"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_IntersectionError
if operation == "C":
scene.cursor.location = vector_delta
elif operation == "P":
pg.pivot_loc = vector_delta
elif operation == "G":
context.view_layer.objects.active.location = vector_delta
pg.error = f"{PDT_INF_OBJ_MOVED} {context.view_layer.objects.active.name}"
context.window_manager.popup_menu(oops, title="Info", icon="INFO")
else:
pg.error = f"{operation} {PDT_ERR_NON_VALID} {PDT_LAB_INTERSECT}"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
return
else:
return
def join_two_vertices(context):
"""Joins 2 Free Vertices that do not form part of a Face.
Joins two vertices that do not form part of a single face
It is designed to close open Edge Loops, where a face is not required
or to join two disconnected Edges.
Args:
context: Blender bpy.context instance.
Returns:
Status Set.
"""
scene = context.scene
pg = scene.pdt_pg
obj = context.view_layer.objects.active
if all([bool(obj), obj.type == "MESH", obj.mode == "EDIT"]):
bm = bmesh.from_edit_mesh(obj.data)
verts = [v for v in bm.verts if v.select]
if len(verts) == 2:
try:
bm.edges.new([verts[-1], verts[-2]])
bmesh.update_edit_mesh(obj.data)
bm.select_history.clear()
return
except ValueError:
pg.error = PDT_ERR_CONNECTED
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_VerticesConnected
else:
pg.error = f"{PDT_ERR_SEL_2_VERTS} {len(verts)})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
else:
pg.error = f"{PDT_ERR_EDOB_MODE},{obj.mode})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_ObjectModeError
def set_angle_distance_two(context):
"""Measures Angle and Offsets between 2 Points in View Plane.
Uses 2 Selected Vertices to set pg.angle and pg.distance scene variables
also sets delta offset from these 2 points using standard Numpy Routines
Works in Edit and Oject Modes.
Args:
context: Blender bpy.context instance.
Returns:
Status Set.
"""
scene = context.scene
pg = scene.pdt_pg
plane = pg.plane
flip_angle = pg.flip_angle
obj = context.view_layer.objects.active
if obj is None:
pg.error = PDT_ERR_NO_ACT_OBJ
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
return
if obj.mode == "EDIT":
bm = bmesh.from_edit_mesh(obj.data)
verts = [v for v in bm.verts if v.select]
if len(verts) == 2:
if len(bm.select_history) == 2:
vector_a, vector_b = check_selection(2, bm, obj)
if vector_a is None:
pg.error = PDT_ERR_VERT_MODE
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_InvalidVector
else:
pg.error = f"{PDT_ERR_SEL_2_VERTIO} {len(bm.select_history)})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
else:
pg.error = f"{PDT_ERR_SEL_2_VERTIO} {len(verts)})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
elif obj.mode == "OBJECT":
objs = context.view_layer.objects.selected
if len(objs) < 2:
pg.error = f"{PDT_ERR_SEL_2_OBJS} {len(objs)})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
objs_s = [ob for ob in objs if ob.name != obj.name]
vector_a = obj.matrix_world.decompose()[0]
vector_b = objs_s[-1].matrix_world.decompose()[0]
if plane == "LO":
vector_difference = vector_b - vector_a
vector_b = view_coords_i(vector_difference.x, vector_difference.y, vector_difference.z)
vector_a = Vector((0, 0, 0))
v0 = np.array([vector_a.x + 1, vector_a.y]) - np.array([vector_a.x, vector_a.y])
v1 = np.array([vector_b.x, vector_b.y]) - np.array([vector_a.x, vector_a.y])
else:
a1, a2, _ = set_mode(plane)
v0 = np.array([vector_a[a1] + 1, vector_a[a2]]) - np.array([vector_a[a1], vector_a[a2]])
v1 = np.array([vector_b[a1], vector_b[a2]]) - np.array([vector_a[a1], vector_a[a2]])
ang = np.rad2deg(np.arctan2(np.linalg.det([v0, v1]), np.dot(v0, v1)))
decimal_places = context.preferences.addons[__package__].preferences.pdt_input_round
if flip_angle:
if ang > 0:
pg.angle = round(ang - 180, decimal_places)
else:
pg.angle = round(ang - 180, decimal_places)
else:
pg.angle = round(ang, decimal_places)
if plane == "LO":
pg.distance = round(sqrt(
(vector_a.x - vector_b.x) ** 2 +
(vector_a.y - vector_b.y) ** 2), decimal_places)
else:
pg.distance = round(sqrt(
(vector_a[a1] - vector_b[a1]) ** 2 +
(vector_a[a2] - vector_b[a2]) ** 2), decimal_places)
pg.cartesian_coords = Vector(([round(i, decimal_places) for i in vector_b - vector_a]))
def set_angle_distance_three(context):
"""Measures Angle and Offsets between 3 Points in World Space, Also sets Deltas.
Uses 3 Selected Vertices to set pg.angle and pg.distance scene variables
also sets delta offset from these 3 points using standard Numpy Routines
Works in Edit and Oject Modes.
Args:
context: Blender bpy.context instance.
Returns:
Status Set.
"""
pg = context.scene.pdt_pg
flip_angle = pg.flip_angle
obj = context.view_layer.objects.active
if obj is None:
pg.error = PDT_ERR_NO_ACT_OBJ
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_NoObjectError
if obj.mode == "EDIT":
bm = bmesh.from_edit_mesh(obj.data)
verts = [v for v in bm.verts if v.select]
if len(verts) == 3:
if len(bm.select_history) == 3:
vector_a, vector_b, vector_c = check_selection(3, bm, obj)
if vector_a is None:
pg.error = PDT_ERR_VERT_MODE
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_InvalidVector
else:
pg.error = f"{PDT_ERR_SEL_3_VERTIO} {len(bm.select_history)})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
else:
pg.error = f"{PDT_ERR_SEL_3_VERTIO} {len(verts)})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
elif obj.mode == "OBJECT":
objs = context.view_layer.objects.selected
if len(objs) < 3:
pg.error = PDT_ERR_SEL_3_OBJS + str(len(objs))
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
objs_s = [ob for ob in objs if ob.name != obj.name]
vector_a = obj.matrix_world.decompose()[0]
vector_b = objs_s[-1].matrix_world.decompose()[0]
vector_c = objs_s[-2].matrix_world.decompose()[0]
ba = np.array([vector_b.x, vector_b.y, vector_b.z]) - np.array(
[vector_a.x, vector_a.y, vector_a.z]
)
bc = np.array([vector_c.x, vector_c.y, vector_c.z]) - np.array(
[vector_a.x, vector_a.y, vector_a.z]
)
angle_cosine = np.dot(ba, bc) / (np.linalg.norm(ba) * np.linalg.norm(bc))
ang = np.degrees(np.arccos(angle_cosine))
decimal_places = context.preferences.addons[__package__].preferences.pdt_input_round
if flip_angle:
if ang > 0:
pg.angle = round(ang - 180, decimal_places)
else:
pg.angle = round(ang - 180, decimal_places)
else:
pg.angle = round(ang, decimal_places)
pg.distance = round((vector_a - vector_b).length, decimal_places)
pg.cartesian_coords = Vector(([round(i, decimal_places) for i in vector_b - vector_a]))
def origin_to_cursor(context):
"""Sets Object Origin in Edit Mode to Cursor Location.
Keeps geometry static in World Space whilst moving Object Origin
Requires cursor location
Works in Edit and Object Modes.
Args:
context: Blender bpy.context instance.
Returns:
Status Set.
"""
scene = context.scene
pg = context.scene.pdt_pg
obj = context.view_layer.objects.active
if obj is None:
pg.error = PDT_ERR_NO_ACT_OBJ
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
return
obj_loc = obj.matrix_world.decompose()[0]
cur_loc = scene.cursor.location
diff_v = obj_loc - cur_loc
if obj.mode == "EDIT":
bm = bmesh.from_edit_mesh(obj.data)
for v in bm.verts:
v.co = v.co + diff_v
obj.location = cur_loc
bmesh.update_edit_mesh(obj.data)
bm.select_history.clear()
elif obj.mode == "OBJECT":
for v in obj.data.vertices:
v.co = v.co + diff_v
obj.location = cur_loc
else:
pg.error = f"{PDT_ERR_EDOB_MODE} {obj.mode})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_ObjectModeError
def taper(context):
"""Taper Geometry along World Axes.
Similar to Shear command except that it shears by angle rather than displacement.
Rotates about World Axes and displaces along World Axes, angle must not exceed +-80 degrees.
Rotation axis is centred on Active Vertex.
Works only in Edit mode.
Args:
context: Blender bpy.context instance.
Note:
Uses pg.taper & pg.angle scene variables
Returns:
Status Set.
"""
scene = context.scene
pg = scene.pdt_pg
tap_ax = pg.taper
ang_v = pg.angle
obj = context.view_layer.objects.active
if all([bool(obj), obj.type == "MESH", obj.mode == "EDIT"]):
if ang_v > 80 or ang_v < -80:
pg.error = f"{PDT_ERR_TAPER_ANG} {ang_v})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_InvalidAngle
if obj is None:
pg.error = PDT_ERR_NO_ACT_OBJ
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_NoObjectError
_, a2, a3 = set_axis(tap_ax)
bm = bmesh.from_edit_mesh(obj.data)
if len(bm.select_history) >= 1:
rotate_vertex = bm.select_history[-1]
view_vector = view_coords(rotate_vertex.co.x, rotate_vertex.co.y, rotate_vertex.co.z)
else:
pg.error = f"{PDT_ERR_TAPER_SEL} {len(bm.select_history)})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_SelectionError
for v in [v for v in bm.verts if v.select]:
if pg.plane == "LO":
v_loc = view_coords(v.co.x, v.co.y, v.co.z)
dis_v = sqrt((view_vector.x - v_loc.x) ** 2 + (view_vector.y - v_loc.y) ** 2)
x_loc = dis_v * tan(ang_v * pi / 180)
view_matrix = view_dir(x_loc, 0)
v.co = v.co - view_matrix
else:
dis_v = sqrt(
(rotate_vertex.co[a3] - v.co[a3]) ** 2 + (rotate_vertex.co[a2] - v.co[a2]) ** 2
)
v.co[a2] = v.co[a2] - (dis_v * tan(ang_v * pi / 180))
bmesh.update_edit_mesh(obj.data)
bm.select_history.clear()
else:
pg.error = f"{PDT_ERR_EDOB_MODE},{obj.mode})"
context.window_manager.popup_menu(oops, title="Error", icon="ERROR")
raise PDT_ObjectModeError