3044 lines
128 KiB
Python
3044 lines
128 KiB
Python
# ##### 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 LICENSE BLOCK #####
|
|
|
|
bl_info = {
|
|
'name': 'Dimension',
|
|
'author': 'Spivak Vladimir (http://cwolf3d.korostyshev.net)',
|
|
'version': (4, 0, 0),
|
|
'blender': (2, 80, 0),
|
|
'location': 'View3D > Add > Curve',
|
|
'description': 'Adds Dimension',
|
|
'warning': '', # used for warning icon and text in addons panel
|
|
'doc_url': 'http://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts/Curve/Dimension',
|
|
"tracker_url": "https://developer.blender.org/maniphest/task/edit/form/2/",
|
|
'category': 'Add Curve'}
|
|
|
|
|
|
##------------------------------------------------------------
|
|
#### import modules
|
|
import bpy
|
|
from bpy.props import *
|
|
from mathutils import *
|
|
from math import *
|
|
from bpy.app.handlers import persistent
|
|
|
|
# Add a TextCurve
|
|
def addText(string = '', loc = ((0, 0, 0)), textsize = 1, align = 'CENTER', offset_y = 0, font = ''):
|
|
|
|
tcu = bpy.data.curves.new(string + 'Data', 'FONT')
|
|
text = bpy.data.objects.new(string + 'Text', tcu)
|
|
tcu.body = string
|
|
tcu.fill_mode = 'BOTH'
|
|
tcu.align_x = align
|
|
tcu.size = textsize
|
|
tcu.offset_y = offset_y
|
|
if font == '':
|
|
fnt = bpy.data.fonts[0]
|
|
else:
|
|
fnt = bpy.data.fonts.load(font)
|
|
tcu.font = fnt
|
|
text.location = loc
|
|
bpy.context.collection.objects.link(text)
|
|
|
|
return text
|
|
|
|
##------------------------------------------------------------
|
|
# Dimension: Linear-1
|
|
def Linear1(width = 2, length = 2, dsize = 1, depth = 0.1, center = False, arrow = 'Arrow1', arrowdepth = 0.1, arrowlength = 0.25):
|
|
|
|
newpoints = []
|
|
|
|
w = 1
|
|
if width < 0:
|
|
w = -1
|
|
l = 1
|
|
if length < 0:
|
|
l = -1
|
|
|
|
if center:
|
|
center1 = w * depth / 2
|
|
center2 = w * depth / 2
|
|
else:
|
|
center1 = 0
|
|
center2 = w * depth
|
|
|
|
if arrow == 'Arrow1' or arrow == 'Arrow2':
|
|
newpoints.append([-center1, 0, 0]) #1
|
|
newpoints.append([-center1, length, 0]) #2
|
|
newpoints.append([-center1, length + l * dsize, 0]) #3
|
|
newpoints.append([center2, length + l * dsize, 0]) #4
|
|
newpoints.append([center2, length + l * dsize / 2 + l * depth / 100, 0]) #5
|
|
newpoints.append([center2 + w * arrowlength, length + l * dsize / 2 + l * arrowdepth + l * depth / 2, 0]) #6
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([center2 + w * arrowlength, length + l * dsize / 2 + l * depth / 2, 0]) #7
|
|
newpoints.append([width-center2-w * arrowlength, length + l * dsize / 2 + l * depth / 2, 0]) #8
|
|
else:
|
|
newpoints.append([center2 + w * arrowlength * 3 / 4, length + l * dsize / 2 + l * depth / 2, 0]) #7
|
|
newpoints.append([width-center2-w * arrowlength * 3 / 4, length + l * dsize / 2 + l * depth / 2, 0]) #8
|
|
newpoints.append([width-center2-w * arrowlength, length + l * dsize / 2 + l * arrowdepth + l * depth / 2, 0]) #9
|
|
newpoints.append([width-center2, length + l * dsize / 2 + l * depth / 100, 0]) #10
|
|
newpoints.append([width-center2, length + l * dsize, 0]) #11
|
|
newpoints.append([width + center1, length + l * dsize, 0]) #12
|
|
newpoints.append([width + center1, length, 0]) #13
|
|
newpoints.append([width + center1, 0, 0]) #14
|
|
newpoints.append([width-center2, 0, 0]) #15
|
|
newpoints.append([width-center2, length, 0]) #16
|
|
newpoints.append([width-center2, length + l * dsize / 2-l * depth / 100, 0]) #17
|
|
newpoints.append([width-center2-w * arrowlength, length + l * dsize / 2-l * arrowdepth-l * depth / 2, 0]) #18
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([width-center2-w * arrowlength, length + l * dsize / 2-l * depth / 2, 0]) #19
|
|
newpoints.append([center2 + w * arrowlength, length + l * dsize / 2-l * depth / 2, 0]) #20
|
|
else:
|
|
newpoints.append([width-center2-w * arrowlength * 3 / 4, length + l * dsize / 2-l * depth / 2, 0]) #19
|
|
newpoints.append([center2 + w * arrowlength * 3 / 4, length + l * dsize / 2-l * depth / 2, 0]) #20
|
|
newpoints.append([center2 + w * arrowlength, length + l * dsize / 2-l * arrowdepth-l * depth / 2, 0]) #21
|
|
newpoints.append([center2, length + l * dsize / 2-l * depth / 100, 0]) #22
|
|
newpoints.append([center2, length, 0]) #23
|
|
newpoints.append([center2, 0, 0]) #24
|
|
|
|
if arrow == 'Serifs1' or arrow == 'Serifs2':
|
|
b = sqrt(depth * depth / 2)
|
|
x = sin(radians(45)) * arrowlength * w
|
|
y = cos(radians(45)) * arrowlength * l
|
|
newpoints.append([-center1, 0, 0]) #1
|
|
newpoints.append([-center1, length, 0]) #2
|
|
newpoints.append([-center1, length + l * dsize / 2-l * depth / 2-l * b, 0]) #3
|
|
newpoints.append([-center1-x, length + l * dsize / 2-l * depth / 2-l * b-y, 0]) #4
|
|
newpoints.append([-center1-w * b-x, length + l * dsize / 2-l * depth / 2-y, 0]) #5
|
|
if arrow == 'Serifs2':
|
|
newpoints.append([-center1-w * b, length + l * dsize / 2-l * depth / 2, 0]) #6
|
|
newpoints.append([-center1-w * dsize / 2, length + l * dsize / 2-l * depth / 2, 0]) #7
|
|
newpoints.append([-center1-w * dsize / 2, length + l * dsize / 2 + l * depth / 2, 0]) #8
|
|
newpoints.append([-center1, length + l * dsize / 2 + l * depth / 2, 0]) #9
|
|
newpoints.append([-center1, length + l * dsize, 0]) #10
|
|
newpoints.append([center2, length + l * dsize, 0]) #11
|
|
newpoints.append([center2, length + l * dsize / 2 + l * depth / 2 + l * b, 0]) #12
|
|
newpoints.append([center2 + x, length + l * dsize / 2 + l * depth / 2 + l * b + y, 0]) #13
|
|
newpoints.append([center2 + w * b + x, length + l * dsize / 2 + l * depth / 2 + y, 0]) #14
|
|
newpoints.append([center2 + w * b, length + l * dsize / 2 + l * depth / 2, 0]) #15
|
|
newpoints.append([width-center2, length + l * dsize / 2 + l * depth / 2, 0]) #16
|
|
newpoints.append([width-center2, length + l * dsize, 0]) #17
|
|
newpoints.append([width + center1, length + l * dsize, 0]) #18
|
|
newpoints.append([width + center1, length + l * dsize / 2 + l * depth / 2 + l * b, 0]) #19
|
|
newpoints.append([width + center1 + x, length + l * dsize / 2 + l * depth / 2 + l * b + y, 0]) #20
|
|
newpoints.append([width + center1 + w * b + x, length + l * dsize / 2 + l * depth / 2 + y, 0]) #21
|
|
if arrow == 'Serifs2':
|
|
newpoints.append([width + center1 + w * b, length + l * dsize / 2 + l * depth / 2, 0]) #22
|
|
newpoints.append([width + center1 + w * dsize / 2, length + l * dsize / 2 + l * depth / 2, 0]) #23
|
|
newpoints.append([width + center1 + w * dsize / 2, length + l * dsize / 2-l * depth / 2, 0]) #24
|
|
newpoints.append([width + center1, length + l * dsize / 2-l * depth / 2, 0]) #25
|
|
newpoints.append([width + center1, length, 0]) #26
|
|
newpoints.append([width + center1, 0, 0]) #27
|
|
newpoints.append([width-center2, 0, 0]) #28
|
|
newpoints.append([width-center2, length, 0]) #29
|
|
newpoints.append([width-center2, length + l * dsize / 2-l * depth / 2-l * b, 0]) #30
|
|
newpoints.append([width-center2-x, length + l * dsize / 2-l * depth / 2-l * b-y, 0]) #31
|
|
newpoints.append([width-center2-w * b-x, length + l * dsize / 2-l * depth / 2-y, 0]) #32
|
|
newpoints.append([width-center2-w * b, length + l * dsize / 2-l * depth / 2, 0]) #33
|
|
newpoints.append([center2, length + l * dsize / 2-l * depth / 2, 0]) #34
|
|
newpoints.append([center2, length, 0]) #35
|
|
newpoints.append([center2, 0, 0]) #36
|
|
|
|
if arrow == 'Without':
|
|
newpoints.append([-center1, 0, 0]) #1
|
|
newpoints.append([-center1, length, 0]) #2
|
|
newpoints.append([-center1, length + l * dsize, 0]) #3
|
|
newpoints.append([center2, length + l * dsize, 0]) #4
|
|
newpoints.append([center2, length + l * dsize / 2 + l * depth / 2, 0]) #7
|
|
newpoints.append([width-center2, length + l * dsize / 2 + l * depth / 2, 0]) #8
|
|
newpoints.append([width-center2, length + l * dsize, 0]) #11
|
|
newpoints.append([width + center1, length + l * dsize, 0]) #12
|
|
newpoints.append([width + center1, length, 0]) #13
|
|
newpoints.append([width + center1, 0, 0]) #14
|
|
newpoints.append([width-center2, 0, 0]) #15
|
|
newpoints.append([width-center2, length, 0]) #16
|
|
newpoints.append([width-center2, length + l * dsize / 2-l * depth / 2, 0]) #19
|
|
newpoints.append([center2, length + l * dsize / 2-l * depth / 2, 0]) #20
|
|
newpoints.append([center2, length, 0]) #23
|
|
newpoints.append([center2, 0, 0]) #24
|
|
|
|
return newpoints
|
|
|
|
##------------------------------------------------------------
|
|
# Dimension: Linear-2
|
|
def Linear2(width = 2, dsize = 1, depth = 0.1, center = False, arrow = 'Arrow1', arrowdepth = 0.25, arrowlength = 0.25):
|
|
|
|
newpoints = []
|
|
|
|
w = 1
|
|
if width < 0:
|
|
w = -1
|
|
|
|
if center:
|
|
center1 = w * depth / 2
|
|
center2 = w * depth / 2
|
|
else:
|
|
center1 = 0
|
|
center2 = w * depth
|
|
|
|
if arrow == 'Arrow1' or arrow == 'Arrow2':
|
|
newpoints.append([0, 0, 0]) #1
|
|
newpoints.append([w * arrowlength, arrowdepth + depth / 2, 0]) #2
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([w * arrowlength, depth / 2, 0]) #3
|
|
newpoints.append([width-w * arrowlength, depth / 2, 0]) #4
|
|
else:
|
|
newpoints.append([w * arrowlength * 3 / 4, depth / 2, 0]) #3
|
|
newpoints.append([width-w * arrowlength * 3 / 4, depth / 2, 0]) #4
|
|
newpoints.append([width-w * arrowlength, arrowdepth + depth / 2, 0]) #5
|
|
newpoints.append([width, 0, 0]) #6
|
|
newpoints.append([width-w * arrowlength, -arrowdepth-depth / 2, 0]) #7
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([width-w * arrowlength, -depth / 2, 0]) #8
|
|
newpoints.append([w * arrowlength, -depth / 2, 0]) #9
|
|
else:
|
|
newpoints.append([width-w * arrowlength * 3 / 4, -depth / 2, 0]) #8
|
|
newpoints.append([w * arrowlength * 3 / 4, -depth / 2, 0]) #9
|
|
newpoints.append([w * arrowlength, -arrowdepth-depth / 2, 0]) #10
|
|
|
|
if arrow == 'Serifs1':
|
|
b = sqrt(depth * depth / 2)
|
|
x = sin(radians(45)) * arrowlength * w
|
|
y = cos(radians(45)) * arrowlength
|
|
newpoints.append([-center1, -dsize / 2, 0]) #2
|
|
newpoints.append([-center1, -depth / 2-b, 0]) #3
|
|
newpoints.append([-center1-x, -depth / 2-b-y, 0]) #4
|
|
newpoints.append([-center1-w * b-x, -depth / 2-y, 0]) #5
|
|
newpoints.append([-center1-w * b, -depth / 2, 0]) #6
|
|
newpoints.append([-center1-w * dsize / 2, -depth / 2, 0]) #7
|
|
newpoints.append([-center1-w * dsize / 2, depth / 2, 0]) #8
|
|
newpoints.append([-center1, depth / 2, 0]) #9
|
|
newpoints.append([-center1, dsize / 2, 0]) #10
|
|
newpoints.append([center2, dsize / 2, 0]) #11
|
|
newpoints.append([center2, depth / 2 + b, 0]) #12
|
|
newpoints.append([center2 + x, depth / 2 + b + y, 0]) #13
|
|
newpoints.append([center2 + w * b + x, depth / 2 + y, 0]) #14
|
|
newpoints.append([center2 + w * b, depth / 2, 0]) #15
|
|
newpoints.append([width-center2, depth / 2, 0]) #16
|
|
newpoints.append([width-center2, dsize / 2, 0]) #17
|
|
newpoints.append([width + center1, dsize / 2, 0]) #18
|
|
newpoints.append([width + center1, depth / 2 + b, 0]) #19
|
|
newpoints.append([width + center1 + x, depth / 2 + b + y, 0]) #20
|
|
newpoints.append([width + center1 + w * b + x, depth / 2 + y, 0]) #21
|
|
newpoints.append([width + center1 + w * b, depth / 2, 0]) #22
|
|
newpoints.append([width + center1 + w * dsize / 2, depth / 2, 0]) #23
|
|
newpoints.append([width + center1 + w * dsize / 2, -depth / 2, 0]) #24
|
|
newpoints.append([width + center1, -depth / 2, 0]) #25
|
|
newpoints.append([width + center1, -dsize / 2, 0]) #26
|
|
newpoints.append([width-center2, -dsize / 2, 0]) #29
|
|
newpoints.append([width-center2, -depth / 2-b, 0]) #30
|
|
newpoints.append([width-center2-x, -depth / 2-b-y, 0]) #31
|
|
newpoints.append([width-center2-w * b-x, -depth / 2-y, 0]) #32
|
|
newpoints.append([width-center2-w * b, -depth / 2, 0]) #33
|
|
newpoints.append([center2, -depth / 2, 0]) #34
|
|
newpoints.append([center2, -dsize / 2, 0]) #35
|
|
|
|
if arrow == 'Serifs2':
|
|
b = sqrt(depth * depth / 2)
|
|
x = sin(radians(45)) * arrowlength * w
|
|
y = cos(radians(45)) * arrowlength
|
|
newpoints.append([-center1 + w * b, -depth / 2, 0]) #3
|
|
newpoints.append([-center1-x, -depth / 2-b-y, 0]) #4
|
|
newpoints.append([-center1-w * b-x, -depth / 2-y, 0]) #5
|
|
newpoints.append([center2 + x, depth / 2 + b + y, 0]) #13
|
|
newpoints.append([center2 + w * b + x, depth / 2 + y, 0]) #14
|
|
newpoints.append([center2 + w * b, depth / 2, 0]) #15
|
|
newpoints.append([width + center1-w * b, depth / 2, 0]) #19
|
|
newpoints.append([width + center1 + x, depth / 2 + b + y, 0]) #20
|
|
newpoints.append([width + center1 + w * b + x, depth / 2 + y, 0]) #21
|
|
newpoints.append([width-center2-x, -depth / 2-b-y, 0]) #31
|
|
newpoints.append([width-center2-w * b-x, -depth / 2-y, 0]) #32
|
|
newpoints.append([width-center2-w * b, -depth / 2, 0]) #33
|
|
|
|
if arrow == 'Without':
|
|
newpoints.append([0, depth / 2, 0]) #3
|
|
newpoints.append([width, depth / 2, 0]) #4
|
|
newpoints.append([width, -depth / 2, 0]) #8
|
|
newpoints.append([0, -depth / 2, 0]) #9
|
|
|
|
return newpoints
|
|
|
|
##------------------------------------------------------------
|
|
# Dimension: Linear-3
|
|
def Linear3(width = 2, length = 2, dsize = 1, depth = 0.1, center = False, arrow = 'Arrow1', arrowdepth = 0.25, arrowlength = 0.25):
|
|
|
|
newpoints = []
|
|
|
|
w = 1
|
|
if width < 0:
|
|
w = -1
|
|
l = 1
|
|
if length < 0:
|
|
l = -1
|
|
|
|
if center:
|
|
center1 = w * depth / 2
|
|
center2 = w * depth / 2
|
|
else:
|
|
center1 = 0
|
|
center2 = w * depth
|
|
|
|
if arrow == 'Arrow1' or arrow == 'Arrow2':
|
|
newpoints.append([-center1, 0, 0]) #1
|
|
newpoints.append([-center1, length, 0]) #2
|
|
newpoints.append([-center1, length + l * dsize / 2-l * depth / 100, 0]) #3
|
|
newpoints.append([-center1-w * arrowlength, length + l * dsize / 2-l * arrowdepth-l * depth / 2, 0]) #4
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([-center1-w * arrowlength, length + l * dsize / 2-l * depth / 2, 0]) #5
|
|
else:
|
|
newpoints.append([-center1-w * arrowlength * 3 / 4, length + l * dsize / 2-l * depth / 2, 0]) #5
|
|
newpoints.append([-center1-w * arrowlength-w * dsize / 2, length + l * dsize / 2-l * depth / 2, 0]) #6
|
|
newpoints.append([-center1-w * arrowlength-w * dsize / 2, length + l * dsize / 2 + l * depth / 2, 0]) #7
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([-center1-w * arrowlength, length + l * dsize / 2 + l * depth / 2, 0]) #8
|
|
else:
|
|
newpoints.append([-center1-w * arrowlength * 3 / 4, length + l * dsize / 2 + l * depth / 2, 0]) #8
|
|
newpoints.append([-center1-w * arrowlength, length + l * dsize / 2 + l * arrowdepth + l * depth / 2, 0]) #9
|
|
newpoints.append([-center1, length + l * dsize / 2 + l * depth / 100, 0]) #10
|
|
newpoints.append([-center1, length + l * dsize, 0]) #11
|
|
newpoints.append([center2, length + l * dsize, 0]) #12
|
|
newpoints.append([center2, length + l * dsize / 2 + l * depth / 2, 0]) #13
|
|
newpoints.append([width-center2, length + l * dsize / 2 + l * depth / 2, 0]) #14
|
|
newpoints.append([width-center2, length + l * dsize, 0]) #15
|
|
newpoints.append([width + center1, length + l * dsize, 0]) #16
|
|
newpoints.append([width + center1, length + l * dsize / 2 + l * depth / 100, 0]) #17
|
|
newpoints.append([width + center1 + w * arrowlength, length + l * dsize / 2 + l * arrowdepth + l * depth / 2, 0]) #18
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([width + center1 + w * arrowlength, length + l * dsize / 2 + l * depth / 2, 0]) #19
|
|
else:
|
|
newpoints.append([width + center1 + w * arrowlength * 3 / 4, length + l * dsize / 2 + l * depth / 2, 0]) #19
|
|
newpoints.append([width + center1 + w * arrowlength + w * dsize / 2, length + l * dsize / 2 + l * depth / 2, 0]) #20
|
|
newpoints.append([width + center1 + w * arrowlength + w * dsize / 2, length + l * dsize / 2-l * depth / 2, 0]) #21
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([width + center1 + w * arrowlength, length + l * dsize / 2-l * depth / 2, 0]) #22
|
|
else:
|
|
newpoints.append([width + center1 + w * arrowlength * 3 / 4, length + l * dsize / 2-l * depth / 2, 0]) #22
|
|
newpoints.append([width + center1 + w * arrowlength, length + l * dsize / 2-l * arrowdepth-l * depth / 2, 0]) #23
|
|
newpoints.append([width + center1, length + l * dsize / 2-l * depth / 100, 0]) #24
|
|
newpoints.append([width + center1, length, 0]) #25
|
|
newpoints.append([width + center1, 0, 0]) #26
|
|
newpoints.append([width-center2, 0, 0]) #27
|
|
newpoints.append([width-center2, length, 0]) #28
|
|
newpoints.append([width-center2, length + l * dsize / 2-l * depth / 2, 0]) #29
|
|
newpoints.append([center2, length + l * dsize / 2-l * depth / 2, 0]) #30
|
|
newpoints.append([center2, length, 0]) #31
|
|
newpoints.append([center2, 0, 0]) #32
|
|
|
|
if arrow == 'Serifs1' or arrow == 'Serifs2':
|
|
b = sqrt(depth * depth / 2)
|
|
x = sin(radians(45)) * arrowlength * w
|
|
y = cos(radians(45)) * arrowlength * l
|
|
newpoints.append([-center1, 0, 0]) #1
|
|
newpoints.append([-center1, length, 0]) #2
|
|
newpoints.append([-center1, length + l * dsize / 2-l * depth / 2-l * b, 0]) #3
|
|
newpoints.append([-center1-x, length + l * dsize / 2-l * depth / 2-l * b-y, 0]) #4
|
|
newpoints.append([-center1-w * b-x, length + l * dsize / 2-l * depth / 2-y, 0]) #5
|
|
newpoints.append([-center1-w * b, length + l * dsize / 2-l * depth / 2, 0]) #6
|
|
if arrow == 'Serifs1':
|
|
newpoints.append([-center1-w * dsize / 2, length + l * dsize / 2-l * depth / 2, 0]) #7
|
|
newpoints.append([-center1-w * dsize / 2, length + l * dsize / 2 + l * depth / 2, 0]) #8
|
|
else:
|
|
newpoints.append([-center1-w * dsize, length + l * dsize / 2-l * depth / 2, 0]) #7
|
|
newpoints.append([-center1-w * dsize, length + l * dsize / 2 + l * depth / 2, 0]) #8
|
|
newpoints.append([-center1, length + l * dsize / 2 + l * depth / 2, 0]) #9
|
|
newpoints.append([-center1, length + l * dsize, 0]) #10
|
|
newpoints.append([center2, length + l * dsize, 0]) #11
|
|
newpoints.append([center2, length + l * dsize / 2 + l * depth / 2 + l * b, 0]) #12
|
|
newpoints.append([center2 + x, length + l * dsize / 2 + l * depth / 2 + l * b + y, 0]) #13
|
|
newpoints.append([center2 + w * b + x, length + l * dsize / 2 + l * depth / 2 + y, 0]) #14
|
|
newpoints.append([center2 + w * b, length + l * dsize / 2 + l * depth / 2, 0]) #15
|
|
newpoints.append([width-center2, length + l * dsize / 2 + l * depth / 2, 0]) #16
|
|
newpoints.append([width-center2, length + l * dsize, 0]) #17
|
|
newpoints.append([width + center1, length + l * dsize, 0]) #18
|
|
newpoints.append([width + center1, length + l * dsize / 2 + l * depth / 2 + l * b, 0]) #19
|
|
newpoints.append([width + center1 + x, length + l * dsize / 2 + l * depth / 2 + l * b + y, 0]) #20
|
|
newpoints.append([width + center1 + w * b + x, length + l * dsize / 2 + l * depth / 2 + y, 0]) #21
|
|
newpoints.append([width + center1 + w * b, length + l * dsize / 2 + l * depth / 2, 0]) #22
|
|
if arrow == 'Serifs1':
|
|
newpoints.append([width + center1 + w * dsize / 2, length + l * dsize / 2 + l * depth / 2, 0]) #23
|
|
newpoints.append([width + center1 + w * dsize / 2, length + l * dsize / 2-l * depth / 2, 0]) #24
|
|
else:
|
|
newpoints.append([width + center1 + w * dsize, length + l * dsize / 2 + l * depth / 2, 0]) #23
|
|
newpoints.append([width + center1 + w * dsize, length + l * dsize / 2-l * depth / 2, 0]) #24
|
|
newpoints.append([width + center1, length + l * dsize / 2-l * depth / 2, 0]) #25
|
|
newpoints.append([width + center1, length, 0]) #26
|
|
newpoints.append([width + center1, 0, 0]) #27
|
|
newpoints.append([width-center2, 0, 0]) #28
|
|
newpoints.append([width-center2, length, 0]) #29
|
|
newpoints.append([width-center2, length + l * dsize / 2-l * depth / 2-l * b, 0]) #30
|
|
newpoints.append([width-center2-x, length + l * dsize / 2-l * depth / 2-l * b-y, 0]) #31
|
|
newpoints.append([width-center2-w * b-x, length + l * dsize / 2-l * depth / 2-y, 0]) #32
|
|
newpoints.append([width-center2-w * b, length + l * dsize / 2-l * depth / 2, 0]) #33
|
|
newpoints.append([center2, length + l * dsize / 2-l * depth / 2, 0]) #34
|
|
newpoints.append([center2, length, 0]) #35
|
|
newpoints.append([center2, 0, 0]) #36
|
|
|
|
if arrow == 'Without':
|
|
newpoints.append([-center1, 0, 0]) #1
|
|
newpoints.append([-center1, length, 0]) #2
|
|
newpoints.append([-center1, length + l * dsize / 2-l * depth / 2, 0]) #5
|
|
newpoints.append([-center1-w * dsize / 2, length + l * dsize / 2-l * depth / 2, 0]) #6
|
|
newpoints.append([-center1-w * dsize / 2, length + l * dsize / 2 + l * depth / 2, 0]) #7
|
|
newpoints.append([-center1, length + l * dsize / 2 + l * depth / 2, 0]) #8
|
|
newpoints.append([-center1, length + l * dsize, 0]) #11
|
|
newpoints.append([center2, length + l * dsize, 0]) #12
|
|
newpoints.append([center2, length + l * dsize / 2 + l * depth / 2, 0]) #13
|
|
newpoints.append([width-center2, length + l * dsize / 2 + l * depth / 2, 0]) #14
|
|
newpoints.append([width-center2, length + l * dsize, 0]) #15
|
|
newpoints.append([width + center1, length + l * dsize, 0]) #16
|
|
newpoints.append([width + center1, length + l * dsize / 2 + l * depth / 2, 0]) #19
|
|
newpoints.append([width + center1 + w * dsize / 2, length + l * dsize / 2 + l * depth / 2, 0]) #20
|
|
newpoints.append([width + center1 + w * dsize / 2, length + l * dsize / 2-l * depth / 2, 0]) #21
|
|
newpoints.append([width + center1, length + l * dsize / 2-l * depth / 2, 0]) #22
|
|
newpoints.append([width + center1, length, 0]) #25
|
|
newpoints.append([width + center1, 0, 0]) #26
|
|
newpoints.append([width-center2, 0, 0]) #27
|
|
newpoints.append([width-center2, length, 0]) #28
|
|
newpoints.append([width-center2, length + l * dsize / 2-l * depth / 2, 0]) #29
|
|
newpoints.append([center2, length + l * dsize / 2-l * depth / 2, 0]) #30
|
|
newpoints.append([center2, length, 0]) #31
|
|
newpoints.append([center2, 0, 0]) #32
|
|
|
|
return newpoints
|
|
|
|
##------------------------------------------------------------
|
|
# Dimension: Radius
|
|
def Radius(width = 2, length = 2, dsize = 1, depth = 0.1, center = False, arrow = 'Arrow1', arrowdepth = 0.25, arrowlength = 0.25):
|
|
|
|
newpoints = []
|
|
|
|
w = 1
|
|
if width < 0:
|
|
w = -1
|
|
length = abs(length)
|
|
|
|
if center:
|
|
center1 = w * depth / 2
|
|
center2 = w * depth / 2
|
|
else:
|
|
center1 = 0
|
|
center2 = w * depth
|
|
|
|
if arrow == 'Arrow1' or arrow == 'Arrow2':
|
|
newpoints.append([0, depth / 2, 0]) #1
|
|
newpoints.append([width, depth / 2, 0]) #2
|
|
newpoints.append([width + w * arrowlength, depth / 2 + arrowdepth, 0]) #3
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([width + w * arrowlength, depth / 2, 0]) #4
|
|
else:
|
|
newpoints.append([width + w * arrowlength * 3 / 4, depth / 2, 0]) #4
|
|
newpoints.append([width + w * arrowlength + w * length, depth / 2, 0]) #5
|
|
newpoints.append([width + w * arrowlength + w * length, -depth / 2, 0]) #6
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([width + w * arrowlength, -depth / 2, 0]) #7
|
|
else:
|
|
newpoints.append([width + w * arrowlength * 3 / 4, -depth / 2, 0]) #7
|
|
newpoints.append([width + w * arrowlength, -depth / 2-arrowdepth, 0]) #8
|
|
newpoints.append([width, -depth / 2, 0]) #9
|
|
newpoints.append([0, -depth / 2, 0]) #10
|
|
|
|
if arrow == 'Serifs1' or arrow == 'Serifs2':
|
|
b = sqrt(depth * depth / 2)
|
|
x = sin(radians(45)) * arrowlength * w
|
|
y = cos(radians(45)) * arrowlength
|
|
newpoints.append([0, depth / 2, 0]) #1
|
|
if arrow == 'Serifs1':
|
|
newpoints.append([width-center2, depth / 2, 0]) #16
|
|
newpoints.append([width-center2, dsize / 2, 0]) #17
|
|
newpoints.append([width + center1, dsize / 2, 0]) #18
|
|
newpoints.append([width + center1, depth / 2 + b, 0]) #19
|
|
else:
|
|
newpoints.append([width + center1-w * b, depth / 2, 0]) #19
|
|
newpoints.append([width + center1 + x, depth / 2 + b + y, 0]) #20
|
|
newpoints.append([width + center1 + w * b + x, depth / 2 + y, 0]) #21
|
|
newpoints.append([width + center1 + w * b, depth / 2, 0]) #22
|
|
newpoints.append([width + center1 + w * length, depth / 2, 0]) #23
|
|
newpoints.append([width + center1 + w * length, -depth / 2, 0]) #24
|
|
if arrow == 'Serifs1':
|
|
newpoints.append([width + center1, -depth / 2, 0]) #25
|
|
newpoints.append([width + center1, -dsize / 2, 0]) #26
|
|
newpoints.append([width-center2, -dsize / 2, 0]) #29
|
|
newpoints.append([width-center2, -depth / 2-b, 0]) #30
|
|
else:
|
|
newpoints.append([width-center2 + w * b, -depth / 2, 0]) #30
|
|
newpoints.append([width-center2-x, -depth / 2-b-y, 0]) #31
|
|
newpoints.append([width-center2-w * b-x, -depth / 2-y, 0]) #32
|
|
newpoints.append([width-center2-w * b, -depth / 2, 0]) #33
|
|
newpoints.append([0, -depth / 2, 0]) #10
|
|
|
|
if arrow == 'Without':
|
|
newpoints.append([0, depth / 2, 0]) #1
|
|
newpoints.append([width, depth / 2, 0]) #2
|
|
newpoints.append([width, -depth / 2, 0]) #9
|
|
newpoints.append([0, -depth / 2, 0]) #10
|
|
|
|
return newpoints
|
|
|
|
##------------------------------------------------------------
|
|
# Dimension: Diameter
|
|
def Diameter(width = 2, length = 2, dsize = 1, depth = 0.1, center = False, arrow = 'Arrow1', arrowdepth = 0.25, arrowlength = 0.25):
|
|
|
|
newpoints = []
|
|
|
|
width = width / 2
|
|
w = 1
|
|
if width < 0:
|
|
w = -1
|
|
length = abs(length)
|
|
|
|
if center:
|
|
center1 = w * depth / 2
|
|
center2 = w * depth / 2
|
|
else:
|
|
center1 = 0
|
|
center2 = w * depth
|
|
|
|
if arrow == 'Arrow1' or arrow == 'Arrow2':
|
|
newpoints.append([0, depth / 2, 0]) #1
|
|
newpoints.append([width, depth / 2, 0]) #2
|
|
newpoints.append([width + w * arrowlength, depth / 2 + arrowdepth, 0]) #3
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([width + w * arrowlength, depth / 2, 0]) #4
|
|
else:
|
|
newpoints.append([width + w * arrowlength * 3 / 4, depth / 2, 0]) #4
|
|
newpoints.append([width + w * arrowlength + w * length, depth / 2, 0]) #5
|
|
newpoints.append([width + w * arrowlength + w * length, -depth / 2, 0]) #6
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([width + w * arrowlength, -depth / 2, 0]) #7
|
|
else:
|
|
newpoints.append([width + w * arrowlength * 3 / 4, -depth / 2, 0]) #7
|
|
newpoints.append([width + w * arrowlength, -depth / 2-arrowdepth, 0]) #8
|
|
newpoints.append([width, -depth / 2, 0]) #9
|
|
newpoints.append([0, -depth / 2, 0]) #10
|
|
newpoints.append([-width, -depth / 2, 0]) #11
|
|
newpoints.append([-width-w * arrowlength, -depth / 2-arrowdepth, 0]) #12
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([-width-w * arrowlength, -depth / 2, 0]) #13
|
|
else:
|
|
newpoints.append([-width-w * arrowlength * 3 / 4, -depth / 2, 0]) #13
|
|
newpoints.append([-width-w * arrowlength-w * length, -depth / 2, 0]) #14
|
|
newpoints.append([-width-w * arrowlength-w * length, depth / 2, 0]) #15
|
|
if arrow == 'Arrow1':
|
|
newpoints.append([-width-w * arrowlength, depth / 2, 0]) #16
|
|
else:
|
|
newpoints.append([-width-w * arrowlength * 3 / 4, depth / 2, 0]) #16
|
|
newpoints.append([-width-w * arrowlength, depth / 2 + arrowdepth, 0]) #17
|
|
newpoints.append([-width, depth / 2, 0]) #18
|
|
|
|
if arrow == 'Serifs1' or arrow == 'Serifs2':
|
|
b = sqrt(depth * depth / 2)
|
|
x = sin(radians(45)) * arrowlength * w
|
|
y = cos(radians(45)) * arrowlength
|
|
newpoints.append([0, depth / 2, 0]) #1
|
|
if arrow == 'Serifs1':
|
|
newpoints.append([width-center2, depth / 2, 0]) #16
|
|
newpoints.append([width-center2, dsize / 2, 0]) #17
|
|
newpoints.append([width + center1, dsize / 2, 0]) #18
|
|
newpoints.append([width + center1, depth / 2 + b, 0]) #19
|
|
else:
|
|
newpoints.append([width + center1-w * b, depth / 2, 0]) #19
|
|
newpoints.append([width + center1 + x, depth / 2 + b + y, 0]) #20
|
|
newpoints.append([width + center1 + w * b + x, depth / 2 + y, 0]) #21
|
|
newpoints.append([width + center1 + w * b, depth / 2, 0]) #22
|
|
newpoints.append([width + center1 + w * length, depth / 2, 0]) #23
|
|
newpoints.append([width + center1 + w * length, -depth / 2, 0]) #24
|
|
if arrow == 'Serifs1':
|
|
newpoints.append([width + center1, -depth / 2, 0]) #25
|
|
newpoints.append([width + center1, -dsize / 2, 0]) #26
|
|
newpoints.append([width-center2, -dsize / 2, 0]) #29
|
|
newpoints.append([width-center2, -depth / 2-b, 0]) #30
|
|
else:
|
|
newpoints.append([width-center2 + w * b, -depth / 2, 0]) #30
|
|
newpoints.append([width-center2-x, -depth / 2-b-y, 0]) #31
|
|
newpoints.append([width-center2-w * b-x, -depth / 2-y, 0]) #32
|
|
newpoints.append([width-center2-w * b, -depth / 2, 0]) #33
|
|
newpoints.append([0, -depth / 2, 0]) #10
|
|
if arrow == 'Serifs1':
|
|
newpoints.append([-width + center2, -depth / 2, 0]) #25
|
|
newpoints.append([-width + center2, -dsize / 2, 0]) #26
|
|
newpoints.append([-width-center1, -dsize / 2, 0]) #29
|
|
newpoints.append([-width-center1, -depth / 2-b, 0]) #30
|
|
else:
|
|
newpoints.append([-width-center1 + w * b, -depth / 2, 0]) #30
|
|
newpoints.append([-width-center1-x, -depth / 2-b-y, 0]) #31
|
|
newpoints.append([-width-center1-w * b-x, -depth / 2-y, 0]) #32
|
|
newpoints.append([-width-center1-w * b, -depth / 2, 0]) #33
|
|
newpoints.append([-width + center2-w * length, -depth / 2, 0]) #24
|
|
newpoints.append([-width + center2-w * length, depth / 2, 0]) #23
|
|
if arrow == 'Serifs1':
|
|
newpoints.append([-width-center1, depth / 2, 0]) #16
|
|
newpoints.append([-width-center1, dsize / 2, 0]) #17
|
|
newpoints.append([-width + center2, dsize / 2, 0]) #18
|
|
newpoints.append([-width + center2, depth / 2 + b, 0]) #19
|
|
else:
|
|
newpoints.append([-width + center2-w * b, depth / 2, 0]) #19
|
|
newpoints.append([-width + center2 + x, depth / 2 + b + y, 0]) #20
|
|
newpoints.append([-width + center2 + w * b + x, depth / 2 + y, 0]) #21
|
|
newpoints.append([-width + center2 + w * b, depth / 2, 0]) #22
|
|
|
|
if arrow == 'Without':
|
|
newpoints.append([0, depth / 2, 0]) #1
|
|
newpoints.append([width, depth / 2, 0]) #2
|
|
newpoints.append([width, -depth / 2, 0]) #9
|
|
newpoints.append([0, -depth / 2, 0]) #10
|
|
newpoints.append([-width, -depth / 2, 0]) #11
|
|
newpoints.append([-width, depth / 2, 0]) #18
|
|
|
|
return newpoints
|
|
|
|
##------------------------------------------------------------
|
|
# Dimension: Angular1
|
|
def Angular1(width = 2, length = 2, depth = 0.1, angle = 45, resolution = 10, center = False, arrow = 'Arrow1', arrowdepth = 0.25, arrowlength = 0.25):
|
|
|
|
newpoints = []
|
|
|
|
if arrow == 'Serifs1' or arrow == 'Serifs2':
|
|
arrow = 'Without'
|
|
|
|
w = 1
|
|
if width < 0:
|
|
w = -1
|
|
|
|
if resolution == 0:
|
|
resolution = 1
|
|
|
|
if arrow == 'Without':
|
|
arrowdepth = 0.0
|
|
arrowlength = 0.0
|
|
|
|
length = abs(length)
|
|
angle = radians(angle)
|
|
|
|
if center:
|
|
center1 = w * depth / 2
|
|
center2 = w * depth / 2
|
|
else:
|
|
center1 = 0
|
|
center2 = w * depth
|
|
|
|
g = hypot(width + w * length, center2)
|
|
u_depth = asin((center2) / g)
|
|
|
|
g = hypot(width, center2)
|
|
u_depth_min = asin((center2 + center2/4) / g)
|
|
|
|
g = hypot(width, arrowlength + w * center2)
|
|
u_arrow = asin((arrowlength + w * center2) / g)
|
|
|
|
if width < 0:
|
|
u_depth = -u_depth
|
|
u_depth_min = -u_depth_min
|
|
|
|
a = 1
|
|
if angle < 0 :
|
|
a = -1
|
|
u_depth = -u_depth
|
|
u_depth_min = -u_depth_min
|
|
u_arrow = -u_arrow
|
|
|
|
x = (a * center1) / tan(angle / 2)
|
|
newpoints.append([-x, -a * center1, 0]) #1
|
|
newpoints.append([width + w * length, -a * center1, 0]) #2
|
|
newpoints.append([width + w * length, a * center2, 0]) #3
|
|
|
|
if arrow == 'Without':
|
|
newpoints.append([width + w * depth / 2, a * center2, 0]) #4
|
|
else:
|
|
newpoints.append([width + w * depth / 100, a * center2, 0]) #4
|
|
|
|
g = width + w * arrowdepth + w * depth / 2
|
|
x = cos(u_arrow + u_depth) * g
|
|
y = sin(u_arrow + u_depth) * g
|
|
newpoints.append([x, y, 0]) #5
|
|
|
|
if arrow == 'Arrow1':
|
|
g = width + w * depth / 2
|
|
x = cos(u_arrow + u_depth) * g
|
|
y = sin(u_arrow + u_depth) * g
|
|
newpoints.append([x, y, 0]) #6
|
|
if arrow == 'Arrow2':
|
|
g = width + w * depth / 2
|
|
x = cos(u_arrow * 3 / 4 + u_depth) * g
|
|
y = sin(u_arrow * 3 / 4 + u_depth) * g
|
|
newpoints.append([x, y, 0]) #6
|
|
|
|
i = 1
|
|
while i < resolution :
|
|
u = i * (angle - u_arrow * 2 - u_depth * 2) / resolution
|
|
g = width + w * depth / 2
|
|
x = cos(u + u_arrow + u_depth) * g
|
|
y = sin(u + u_arrow + u_depth) * g
|
|
newpoints.append([x, y, 0]) #n
|
|
i += 1
|
|
|
|
if arrow == 'Arrow1':
|
|
g = width + w * depth / 2
|
|
x = cos(angle - u_arrow - u_depth) * g
|
|
y = sin(angle - u_arrow - u_depth) * g
|
|
newpoints.append([x, y, 0]) #7
|
|
if arrow == 'Arrow2':
|
|
g = width + w * depth / 2
|
|
x = cos(angle - u_arrow * 3 / 4 - u_depth) * g
|
|
y = sin(angle - u_arrow * 3 / 4 - u_depth) * g
|
|
newpoints.append([x, y, 0]) #7
|
|
|
|
u = angle - u_arrow - u_depth
|
|
g = width + w * arrowdepth + w * depth / 2
|
|
x = cos(u) * g
|
|
y = sin(u) * g
|
|
newpoints.append([x, y, 0]) #8
|
|
|
|
if arrow == 'Without':
|
|
g = width + w * depth / 2
|
|
x = cos(angle-u_depth_min) * g
|
|
y = sin(angle-u_depth_min) * g
|
|
newpoints.append([x, y, 0]) #9
|
|
else:
|
|
g = width + w * depth / 100
|
|
x = cos(angle-u_depth_min) * g
|
|
y = sin(angle-u_depth_min) * g
|
|
newpoints.append([x, y, 0]) #9
|
|
|
|
if arrow == 'Without':
|
|
g = width-w * depth / 2
|
|
x = cos(angle-u_depth_min) * g
|
|
y = sin(angle-u_depth_min) * g
|
|
newpoints.append([x, y, 0]) #10
|
|
else:
|
|
g = width-w * depth / 100
|
|
x = cos(angle-u_depth_min) * g
|
|
y = sin(angle-u_depth_min) * g
|
|
newpoints.append([x, y, 0]) #10
|
|
|
|
g = width-w * arrowdepth-w * depth / 2
|
|
x = cos(u) * g
|
|
y = sin(u) * g
|
|
newpoints.append([x, y, 0]) #11
|
|
|
|
if arrow == 'Arrow1':
|
|
u = angle - u_arrow - u_depth
|
|
g = width-w * depth / 2
|
|
x = cos(u) * g
|
|
y = sin(u) * g
|
|
newpoints.append([x, y, 0]) #12
|
|
if arrow == 'Arrow2':
|
|
u = angle - u_arrow * 3 / 4 - u_depth
|
|
g = width-w * depth / 2
|
|
x = cos(u) * g
|
|
y = sin(u) * g
|
|
newpoints.append([x, y, 0]) #12
|
|
|
|
i = resolution - 1
|
|
while i >= 1 :
|
|
u = i * (angle - u_arrow * 2 - u_depth * 2) / resolution
|
|
g = width-w * depth / 2
|
|
x = cos(u + u_arrow + u_depth) * g
|
|
y = sin(u + u_arrow + u_depth) * g
|
|
newpoints.append([x, y, 0]) #n
|
|
i -= 1
|
|
|
|
if arrow == 'Arrow1':
|
|
g = width-w * depth / 2
|
|
x = cos(u_arrow + u_depth) * g
|
|
y = sin(u_arrow + u_depth) * g
|
|
newpoints.append([x, y, 0]) #13
|
|
if arrow == 'Arrow2':
|
|
g = width-w * depth / 2
|
|
x = cos(u_arrow * 3 / 4 + u_depth) * g
|
|
y = sin(u_arrow * 3 / 4 + u_depth) * g
|
|
newpoints.append([x, y, 0]) #13
|
|
|
|
g = width-w * arrowdepth-w * depth / 2
|
|
x = cos(u_arrow + u_depth) * g
|
|
y = sin(u_arrow + u_depth) * g
|
|
newpoints.append([x, y, 0]) #14
|
|
|
|
if arrow == 'Without':
|
|
newpoints.append([width-w * depth / 2, a * center2, 0]) #15
|
|
else:
|
|
newpoints.append([width-w * depth / 100, a * center2, 0]) #15
|
|
|
|
x = (a * center2) / tan(angle / 2)
|
|
newpoints.append([x, a * center2, 0]) #16
|
|
|
|
g = width + w * length
|
|
x = cos(angle-u_depth) * g
|
|
y = sin(angle-u_depth) * g
|
|
newpoints.append([x, y, 0]) #17
|
|
|
|
if center:
|
|
g = width + w * length
|
|
x = cos(angle + u_depth) * g
|
|
y = sin(angle + u_depth) * g
|
|
newpoints.append([x, y, 0]) #18
|
|
else:
|
|
g = width + w * length
|
|
x = cos(angle) * g
|
|
y = sin(angle) * g
|
|
newpoints.append([x, y, 0]) #18
|
|
|
|
return newpoints
|
|
|
|
##------------------------------------------------------------
|
|
# Dimension: Angular2
|
|
def Angular2(width = 2, depth = 0.1, angle = 45, resolution = 10, arrow = 'Arrow1', arrowdepth = 0.25, arrowlength = 0.25):
|
|
|
|
newpoints = []
|
|
|
|
if arrow == 'Serifs1' or arrow == 'Serifs2':
|
|
arrow = 'Without'
|
|
|
|
w = 1
|
|
if width < 0:
|
|
w = -1
|
|
|
|
if resolution == 0:
|
|
resolution = 1
|
|
|
|
if arrow == 'Without':
|
|
arrowdepth = 0.0
|
|
arrowlength = 0.0
|
|
|
|
angle = radians(angle)
|
|
|
|
newpoints.append([width, 0, 0]) #1
|
|
|
|
g = hypot(width + w * depth / 2, arrowlength)
|
|
u_arrow = asin((arrowlength) / g)
|
|
if angle < 0 :
|
|
u_arrow = -u_arrow
|
|
|
|
g = width + w * arrowdepth + w * depth / 2
|
|
x = cos(u_arrow) * g
|
|
y = sin(u_arrow) * g
|
|
newpoints.append([x, y, 0]) #2
|
|
|
|
if arrow == 'Arrow1':
|
|
g = width + w * depth / 2
|
|
x = cos(u_arrow) * g
|
|
y = sin(u_arrow) * g
|
|
newpoints.append([x, y, 0]) #3
|
|
|
|
if arrow == 'Arrow2':
|
|
g = width + w * depth / 2
|
|
x = cos(u_arrow * 3 / 4) * g
|
|
y = sin(u_arrow * 3 / 4) * g
|
|
newpoints.append([x, y, 0]) #3
|
|
|
|
i = 1
|
|
while i < resolution :
|
|
u = i * (angle - u_arrow * 2) / resolution
|
|
g = width + w * depth / 2
|
|
x = cos(u + u_arrow) * g
|
|
y = sin(u + u_arrow) * g
|
|
newpoints.append([x, y, 0]) #n
|
|
i += 1
|
|
|
|
if arrow == 'Arrow1':
|
|
u = angle - u_arrow
|
|
g = width + w * depth / 2
|
|
x = cos(u) * g
|
|
y = sin(u) * g
|
|
newpoints.append([x, y, 0]) #4
|
|
if arrow == 'Arrow2':
|
|
u = angle - u_arrow * 3 / 4
|
|
g = width + w * depth / 2
|
|
x = cos(u) * g
|
|
y = sin(u) * g
|
|
newpoints.append([x, y, 0]) #4
|
|
|
|
u = angle - u_arrow
|
|
g = width + w * arrowdepth + w * depth / 2
|
|
x = cos(u) * g
|
|
y = sin(u) * g
|
|
newpoints.append([x, y, 0]) #5
|
|
|
|
g = width
|
|
x = cos(angle) * g
|
|
y = sin(angle) * g
|
|
newpoints.append([x, y, 0]) #6
|
|
|
|
g = width-w * arrowdepth-w * depth / 2
|
|
x = cos(u) * g
|
|
y = sin(u) * g
|
|
newpoints.append([x, y, 0]) #7
|
|
|
|
if arrow == 'Arrow1':
|
|
u = angle - u_arrow
|
|
g = width-w * depth / 2
|
|
x = cos(u) * g
|
|
y = sin(u) * g
|
|
newpoints.append([x, y, 0]) #8
|
|
if arrow == 'Arrow2':
|
|
u = angle - u_arrow * 3 / 4
|
|
g = width-w * depth / 2
|
|
x = cos(u) * g
|
|
y = sin(u) * g
|
|
newpoints.append([x, y, 0]) #8
|
|
|
|
i = resolution - 1
|
|
while i > 0 :
|
|
u = i * (angle - u_arrow * 2) / resolution
|
|
g = width-w * depth / 2
|
|
x = cos(u + u_arrow) * g
|
|
y = sin(u + u_arrow) * g
|
|
newpoints.append([x, y, 0]) #n
|
|
i -= 1
|
|
|
|
if arrow == 'Arrow1':
|
|
g = width-w * depth / 2
|
|
x = cos(u_arrow) * g
|
|
y = sin(u_arrow) * g
|
|
newpoints.append([x, y, 0]) #9
|
|
if arrow == 'Arrow2':
|
|
g = width-w * depth / 2
|
|
x = cos(u_arrow * 3 / 4) * g
|
|
y = sin(u_arrow * 3 / 4) * g
|
|
newpoints.append([x, y, 0]) #9
|
|
|
|
g = width-w * arrowdepth-w * depth / 2
|
|
x = cos(u_arrow) * g
|
|
y = sin(u_arrow) * g
|
|
newpoints.append([x, y, 0]) #10
|
|
|
|
return newpoints
|
|
|
|
##------------------------------------------------------------
|
|
# Dimension: Angular3
|
|
def Angular3(width = 2, length = 2, dsize = 1, depth = 0.1, angle = 45, resolution = 10, center = False, arrow = 'Arrow1', arrowdepth = 0.25, arrowlength = 0.25):
|
|
|
|
newpoints = []
|
|
|
|
if arrow == 'Serifs1' or arrow == 'Serifs2':
|
|
arrow = 'Without'
|
|
|
|
w = 1
|
|
if width < 0:
|
|
w = -1
|
|
|
|
if resolution == 0:
|
|
resolution = 1
|
|
|
|
if arrow == 'Without':
|
|
arrowdepth = 0.0
|
|
arrowlength = 0.0
|
|
|
|
resolution_2 = floor(resolution / 2)
|
|
|
|
length = abs(length)
|
|
angle = radians(angle)
|
|
|
|
if center:
|
|
center1 = w * depth / 2
|
|
center2 = w * depth / 2
|
|
else:
|
|
center1 = 0
|
|
center2 = w * depth
|
|
|
|
g = hypot(width + w * length, center2)
|
|
u_depth = asin((center2) / g)
|
|
|
|
g = hypot(width + depth / 2, center2)
|
|
u_depth_13 = asin((center2 + center2/4) / g)
|
|
|
|
g = hypot(width-depth / 2, center2)
|
|
u_depth_14 = asin((center2 + center2/4) / g)
|
|
|
|
g = hypot(width, center2)
|
|
u_depth_min = asin((center2) / g)
|
|
|
|
g = hypot(width, arrowlength + w * center2)
|
|
u_arrow = asin((arrowlength + w * center2) / g)
|
|
|
|
g = hypot(width, arrowlength + w * center2 + dsize)
|
|
u_dsize = asin((arrowlength + w * center2 + dsize) / g)
|
|
|
|
if width < 0:
|
|
u_depth = -u_depth
|
|
u_depth_min = -u_depth_min
|
|
u_depth_13 = -u_depth_13
|
|
u_depth_14 = -u_depth_14
|
|
|
|
a = 1
|
|
if angle < 0 :
|
|
a = -1
|
|
u_depth = -u_depth
|
|
u_depth_min = -u_depth_min
|
|
u_arrow = -u_arrow
|
|
u_depth_13 = -u_depth_13
|
|
u_depth_14 = -u_depth_14
|
|
|
|
x = (a * center1) / tan(angle / 2)
|
|
newpoints.append([-x, -a * center1, 0]) #1
|
|
|
|
if arrow == 'Without':
|
|
newpoints.append([width-w * depth / 2, -a * center1, 0]) #2
|
|
else:
|
|
newpoints.append([width-w * depth / 100, -a * center1, 0]) #2
|
|
|
|
g = width-w * arrowdepth-w * depth / 2
|
|
x = cos(-u_arrow-u_depth) * g
|
|
y = sin(-u_arrow-u_depth) * g
|
|
newpoints.append([x, y, 0]) #3
|
|
|
|
if arrow == 'Arrow1':
|
|
g = width-w * depth / 2
|
|
x = cos(-u_arrow-u_depth) * g
|
|
y = sin(-u_arrow-u_depth) * g
|
|
newpoints.append([x, y, 0]) #4
|
|
if arrow == 'Arrow2':
|
|
g = width-w * depth / 2
|
|
x = cos(-u_arrow * 3 / 4-u_depth) * g
|
|
y = sin(-u_arrow * 3 / 4-u_depth) * g
|
|
newpoints.append([x, y, 0]) #4
|
|
|
|
i = 1
|
|
while i < resolution_2 :
|
|
u = i * (-u_dsize) / resolution_2
|
|
g = width-w * depth / 2
|
|
x = cos(u-u_arrow) * g
|
|
y = sin(u-u_arrow) * g
|
|
newpoints.append([x, y, 0]) #n
|
|
i += 1
|
|
|
|
g = width-w * depth / 2
|
|
x = cos(-u_arrow-u_depth-u_dsize) * g
|
|
y = sin(-u_arrow-u_depth-u_dsize) * g
|
|
newpoints.append([x, y, 0]) #5
|
|
|
|
g = width + w * depth / 2
|
|
x = cos(-u_arrow-u_depth-u_dsize) * g
|
|
y = sin(-u_arrow-u_depth-u_dsize) * g
|
|
newpoints.append([x, y, 0]) #6
|
|
|
|
i = resolution_2
|
|
while i >= 1 :
|
|
u = i * (-u_dsize) / resolution_2
|
|
g = width + w * depth / 2
|
|
x = cos(u-u_arrow) * g
|
|
y = sin(u-u_arrow) * g
|
|
newpoints.append([x, y, 0]) #n
|
|
i -= 1
|
|
|
|
if arrow == 'Arrow1':
|
|
g = width + w * depth / 2
|
|
x = cos(-u_arrow-u_depth) * g
|
|
y = sin(-u_arrow-u_depth) * g
|
|
newpoints.append([x, y, 0]) #7
|
|
if arrow == 'Arrow2':
|
|
g = width + w * depth / 2
|
|
x = cos(-u_arrow * 3 / 4-u_depth) * g
|
|
y = sin(-u_arrow * 3 / 4-u_depth) * g
|
|
newpoints.append([x, y, 0]) #7
|
|
|
|
g = width + w * arrowdepth + w * depth / 2
|
|
x = cos(-u_arrow-u_depth) * g
|
|
y = sin(-u_arrow-u_depth) * g
|
|
newpoints.append([x, y, 0]) #8
|
|
|
|
if arrow == 'Without':
|
|
newpoints.append([width + w * depth / 2, -a * center1, 0]) #9
|
|
else:
|
|
newpoints.append([width + w * depth / 100, -a * center1, 0]) #9
|
|
|
|
newpoints.append([width + w * length, -a * center1, 0]) #10
|
|
|
|
newpoints.append([width + w * length, a * center2, 0]) #11
|
|
|
|
g = width + w * depth / 2
|
|
x = cos(u_depth_min) * g
|
|
y = sin(u_depth_min) * g
|
|
newpoints.append([x, y, 0]) #12
|
|
|
|
i = 1
|
|
while i < resolution :
|
|
u = i * (angle - u_depth * 2) / resolution
|
|
g = width + w * depth / 2
|
|
x = cos(u + u_depth) * g
|
|
y = sin(u + u_depth) * g
|
|
newpoints.append([x, y, 0]) #n
|
|
i += 1
|
|
|
|
if width > 0 :
|
|
g = width + w * depth / 2
|
|
x = cos(angle - u_depth_13) * g
|
|
y = sin(angle - u_depth_13) * g
|
|
newpoints.append([x, y, 0]) #13
|
|
|
|
g = width-w * depth / 2
|
|
x = cos(angle - u_depth_14) * g
|
|
y = sin(angle - u_depth_14) * g
|
|
newpoints.append([x, y, 0]) #14
|
|
else:
|
|
g = width + w * depth / 2
|
|
x = cos(angle - u_depth_14) * g
|
|
y = sin(angle - u_depth_14) * g
|
|
newpoints.append([x, y, 0]) #13
|
|
|
|
g = width-w * depth / 2
|
|
x = cos(angle - u_depth_13) * g
|
|
y = sin(angle - u_depth_13) * g
|
|
newpoints.append([x, y, 0]) #14
|
|
|
|
i = resolution - 1
|
|
while i >= 1 :
|
|
u = i * (angle - u_depth * 2) / resolution
|
|
g = width-w * depth / 2
|
|
x = cos(u + u_depth) * g
|
|
y = sin(u + u_depth) * g
|
|
newpoints.append([x, y, 0]) #n
|
|
i -= 1
|
|
|
|
g = width-w * depth / 2
|
|
x = cos(u_depth_min) * g
|
|
y = sin(u_depth_min) * g
|
|
newpoints.append([x, y, 0]) #15
|
|
|
|
x = (a * center2) / tan(angle / 2)
|
|
newpoints.append([x, a * center2, 0]) #16
|
|
|
|
g = width + w * length
|
|
x = cos(angle-u_depth) * g
|
|
y = sin(angle-u_depth) * g
|
|
newpoints.append([x, y, 0]) #17
|
|
|
|
if center:
|
|
g = width + w * length
|
|
x = cos(angle + u_depth) * g
|
|
y = sin(angle + u_depth) * g
|
|
newpoints.append([x, y, 0]) #18
|
|
|
|
if arrow == 'Without':
|
|
g = width + w * depth / 2
|
|
x = cos(angle + u_depth) * g
|
|
y = sin(angle + u_depth) * g
|
|
newpoints.append([x, y, 0]) #19
|
|
else:
|
|
g = width + w * depth / 100
|
|
x = cos(angle + u_depth) * g
|
|
y = sin(angle + u_depth) * g
|
|
newpoints.append([x, y, 0]) #19
|
|
else:
|
|
g = width + w * length
|
|
x = cos(angle) * g
|
|
y = sin(angle) * g
|
|
newpoints.append([x, y, 0]) #18
|
|
|
|
if arrow == 'Without':
|
|
g = width + w * depth / 2
|
|
x = cos(angle) * g
|
|
y = sin(angle) * g
|
|
newpoints.append([x, y, 0]) #19
|
|
else:
|
|
g = width + w * depth / 100
|
|
x = cos(angle) * g
|
|
y = sin(angle) * g
|
|
newpoints.append([x, y, 0]) #19
|
|
|
|
g = width + w * arrowdepth + w * depth / 2
|
|
x = cos(angle + u_arrow + u_depth) * g
|
|
y = sin(angle + u_arrow + u_depth) * g
|
|
newpoints.append([x, y, 0]) #20
|
|
|
|
if arrow == 'Arrow1':
|
|
g = width + w * depth / 2
|
|
x = cos(angle + u_arrow + u_depth) * g
|
|
y = sin(angle + u_arrow + u_depth) * g
|
|
newpoints.append([x, y, 0]) #21
|
|
if arrow == 'Arrow2':
|
|
g = width + w * depth / 2
|
|
x = cos(angle + u_arrow * 3 / 4 + u_depth) * g
|
|
y = sin(angle + u_arrow * 3 / 4 + u_depth) * g
|
|
newpoints.append([x, y, 0]) #21
|
|
|
|
i = 1
|
|
while i < resolution_2 :
|
|
u = i * (u_dsize) / resolution_2
|
|
g = width + w * depth / 2
|
|
x = cos(u + angle + u_arrow) * g
|
|
y = sin(u + angle + u_arrow) * g
|
|
newpoints.append([x, y, 0]) #n
|
|
i += 1
|
|
|
|
g = width + w * depth / 2
|
|
x = cos(angle + u_arrow + u_depth + u_dsize) * g
|
|
y = sin(angle + u_arrow + u_depth + u_dsize) * g
|
|
newpoints.append([x, y, 0]) #22
|
|
|
|
g = width-w * depth / 2
|
|
x = cos(angle + u_arrow + u_depth + u_dsize) * g
|
|
y = sin(angle + u_arrow + u_depth + u_dsize) * g
|
|
newpoints.append([x, y, 0]) #23
|
|
|
|
i = resolution_2
|
|
while i >= 1 :
|
|
u = i * (u_dsize) / resolution_2
|
|
g = width-w * depth / 2
|
|
x = cos(u + angle + u_arrow) * g
|
|
y = sin(u + angle + u_arrow) * g
|
|
newpoints.append([x, y, 0]) #n
|
|
i -= 1
|
|
|
|
if arrow == 'Arrow1':
|
|
g = width-w * depth / 2
|
|
x = cos(angle + u_arrow + u_depth) * g
|
|
y = sin(angle + u_arrow + u_depth) * g
|
|
newpoints.append([x, y, 0]) #24
|
|
if arrow == 'Arrow2':
|
|
g = width-w * depth / 2
|
|
x = cos(angle + u_arrow * 3 / 4 + u_depth) * g
|
|
y = sin(angle + u_arrow * 3 / 4 + u_depth) * g
|
|
newpoints.append([x, y, 0]) #24
|
|
|
|
g = width-w * arrowdepth-w * depth / 2
|
|
x = cos(angle + u_arrow + u_depth) * g
|
|
y = sin(angle + u_arrow + u_depth) * g
|
|
newpoints.append([x, y, 0]) #25
|
|
|
|
if center:
|
|
if arrow == 'Without':
|
|
g = width-w * depth / 2
|
|
x = cos(angle + u_depth) * g
|
|
y = sin(angle + u_depth) * g
|
|
newpoints.append([x, y, 0]) #26
|
|
else:
|
|
g = width-w * depth / 100
|
|
x = cos(angle + u_depth) * g
|
|
y = sin(angle + u_depth) * g
|
|
newpoints.append([x, y, 0]) #26
|
|
else:
|
|
if arrow == 'Without':
|
|
g = width-w * depth / 2
|
|
x = cos(angle) * g
|
|
y = sin(angle) * g
|
|
newpoints.append([x, y, 0]) #26
|
|
else:
|
|
g = width-w * depth / 100
|
|
x = cos(angle) * g
|
|
y = sin(angle) * g
|
|
newpoints.append([x, y, 0]) #26
|
|
|
|
return newpoints
|
|
|
|
##------------------------------------------------------------
|
|
# Dimension: Note
|
|
def Note(width = 2, length = 2, depth = 0.1, angle = 45, arrow = 'Arrow1', arrowdepth = 0.25, arrowlength = 0.25):
|
|
|
|
newpoints = []
|
|
|
|
if arrow == 'Serifs1' or arrow == 'Serifs2':
|
|
arrow = 'Without'
|
|
|
|
w = 1
|
|
if width < 0:
|
|
w = -1
|
|
angle = radians(angle)
|
|
length = abs(length)
|
|
|
|
if cos(angle) > 0:
|
|
newpoints.append([0, 0, 0]) #1
|
|
|
|
if arrow == 'Arrow1':
|
|
g = hypot(arrowlength, depth / 2 + arrowdepth)
|
|
u = asin((depth / 2 + arrowdepth) / g)
|
|
x = cos(angle + u) * g
|
|
y = sin(angle + u) * g
|
|
newpoints.append([w * x, y, 0]) #2
|
|
|
|
g = hypot(arrowlength, depth / 2)
|
|
u = asin((depth / 2) / g)
|
|
x = cos(angle + u) * g
|
|
y = sin(angle + u) * g
|
|
newpoints.append([w * x, y, 0]) #3
|
|
|
|
if arrow == 'Arrow2':
|
|
g = hypot(arrowlength, depth / 2 + arrowdepth)
|
|
u = asin((depth / 2 + arrowdepth) / g)
|
|
x = cos(angle + u) * g
|
|
y = sin(angle + u) * g
|
|
newpoints.append([w * x, y, 0]) #2
|
|
|
|
g = hypot(arrowlength * 3 / 4, depth / 2)
|
|
u = asin((depth / 2) / g)
|
|
x = cos(angle + u) * g
|
|
y = sin(angle + u) * g
|
|
newpoints.append([w * x, y, 0]) #3
|
|
|
|
if arrow == 'Without':
|
|
g = w * depth / 2
|
|
x = cos(angle + radians(90)) * g
|
|
y = sin(angle + radians(90)) * g
|
|
newpoints.append([x, y, 0]) #2
|
|
|
|
g = hypot(width, depth / 2)
|
|
u = asin((depth / 2) / g)
|
|
x = cos(angle + u) * g
|
|
y = sin(angle) * width
|
|
newpoints.append([w * x, y + w * depth / 2, 0]) #4
|
|
|
|
newpoints.append([w * x + w * length, y + w * depth / 2, 0]) #5
|
|
newpoints.append([w * x + w * length, y-w * depth / 2, 0]) #6
|
|
|
|
g = hypot(width, depth / 2)
|
|
u = asin((depth / 2) / g)
|
|
y = sin(angle) * width
|
|
x = cos(angle-u) * g
|
|
newpoints.append([w * x, y-w * depth / 2, 0]) #7
|
|
|
|
if arrow == 'Arrow1':
|
|
g = hypot(arrowlength, depth / 2)
|
|
u = asin((depth / 2) / g)
|
|
x = cos(angle-u) * g
|
|
y = sin(angle-u) * g
|
|
newpoints.append([w * x, y, 0]) #8
|
|
|
|
g = hypot(arrowlength, depth / 2 + arrowdepth)
|
|
u = asin((depth / 2 + arrowdepth) / g)
|
|
x = cos(angle-u) * g
|
|
y = sin(angle-u) * g
|
|
newpoints.append([w * x, y, 0]) #9
|
|
|
|
if arrow == 'Arrow2':
|
|
g = hypot(arrowlength * 3 / 4, depth / 2)
|
|
u = asin((depth / 2) / g)
|
|
x = cos(angle-u) * g
|
|
y = sin(angle-u) * g
|
|
newpoints.append([w * x, y, 0]) #8
|
|
|
|
g = hypot(arrowlength, depth / 2 + arrowdepth)
|
|
u = asin((depth / 2 + arrowdepth) / g)
|
|
x = cos(angle-u) * g
|
|
y = sin(angle-u) * g
|
|
newpoints.append([w * x, y, 0]) #9
|
|
|
|
if arrow == 'Without':
|
|
g = -w * depth / 2
|
|
x = cos(angle + radians(90)) * g
|
|
y = sin(angle + radians(90)) * g
|
|
newpoints.append([x, y, 0]) #6
|
|
|
|
else:
|
|
newpoints.append([0, 0, 0]) #1
|
|
|
|
if arrow == 'Arrow1':
|
|
g = hypot(arrowlength, depth / 2 + arrowdepth)
|
|
u = asin((depth / 2 + arrowdepth) / g)
|
|
x = cos(angle-u) * g
|
|
y = sin(angle-u) * g
|
|
newpoints.append([w * x, y, 0]) #2
|
|
|
|
g = hypot(arrowlength, depth / 2)
|
|
u = asin((depth / 2) / g)
|
|
x = cos(angle-u) * g
|
|
y = sin(angle-u) * g
|
|
newpoints.append([w * x, y, 0]) #3
|
|
|
|
if arrow == 'Arrow2':
|
|
g = hypot(arrowlength, depth / 2 + arrowdepth)
|
|
u = asin((depth / 2 + arrowdepth) / g)
|
|
x = cos(angle-u) * g
|
|
y = sin(angle-u) * g
|
|
newpoints.append([w * x, y, 0]) #2
|
|
|
|
g = hypot(arrowlength * 3 / 4, depth / 2)
|
|
u = asin((depth / 2) / g)
|
|
x = cos(angle-u) * g
|
|
y = sin(angle-u) * g
|
|
newpoints.append([w * x, y, 0]) #3
|
|
|
|
if arrow == 'Without':
|
|
g = -w * depth / 2
|
|
x = cos(angle + radians(90)) * g
|
|
y = sin(angle + radians(90)) * g
|
|
newpoints.append([x, y, 0]) #2
|
|
|
|
g = hypot(width, depth / 2)
|
|
u = asin((depth / 2) / g)
|
|
x = cos(angle-u) * g
|
|
y = sin(angle) * width
|
|
newpoints.append([w * x, y + w * depth / 2, 0]) #4
|
|
|
|
newpoints.append([w * x-w * length, y + w * depth / 2, 0]) #5
|
|
newpoints.append([w * x-w * length, y-w * depth / 2, 0]) #6
|
|
|
|
g = hypot(width, depth / 2)
|
|
u = asin((depth / 2) / g)
|
|
y = sin(angle) * width
|
|
x = cos(angle + u) * g
|
|
newpoints.append([w * x, y-w * depth / 2, 0]) #7
|
|
|
|
if arrow == 'Arrow1':
|
|
g = hypot(arrowlength, depth / 2)
|
|
u = asin((depth / 2) / g)
|
|
x = cos(angle + u) * g
|
|
y = sin(angle + u) * g
|
|
newpoints.append([w * x, y, 0]) #8
|
|
|
|
g = hypot(arrowlength, depth / 2 + arrowdepth)
|
|
u = asin((depth / 2 + arrowdepth) / g)
|
|
x = cos(angle + u) * g
|
|
y = sin(angle + u) * g
|
|
newpoints.append([w * x, y, 0]) #9
|
|
|
|
if arrow == 'Arrow2':
|
|
g = hypot(arrowlength * 3 / 4, depth / 2)
|
|
u = asin((depth / 2) / g)
|
|
x = cos(angle + u) * g
|
|
y = sin(angle + u) * g
|
|
newpoints.append([w * x, y, 0]) #8
|
|
|
|
g = hypot(arrowlength, depth / 2 + arrowdepth)
|
|
u = asin((depth / 2 + arrowdepth) / g)
|
|
x = cos(angle + u) * g
|
|
y = sin(angle + u) * g
|
|
newpoints.append([w * x, y, 0]) #9
|
|
|
|
if arrow == 'Without':
|
|
g = w * depth / 2
|
|
x = cos(angle + radians(90)) * g
|
|
y = sin(angle + radians(90)) * g
|
|
newpoints.append([x, y, 0]) #6
|
|
|
|
return newpoints
|
|
|
|
##------------------------------------------------------------
|
|
# make and set Material
|
|
def makeMaterial(name, diffuse, specular, alpha):
|
|
|
|
mat = bpy.data.materials.new(name)
|
|
mat.diffuse_color = diffuse
|
|
#mat.diffuse_shader = 'LAMBERT'
|
|
#mat.diffuse_intensity = 1.0
|
|
mat.specular_color = specular
|
|
#mat.specular_shader = 'COOKTORR'
|
|
mat.specular_intensity = 0.0
|
|
mat.roughness = 0.0
|
|
#mat.alpha = alpha
|
|
#mat.ambient = 1
|
|
#mat.specular_hardness = 1
|
|
#mat.use_shadeless = True
|
|
|
|
return mat
|
|
|
|
def setMaterial(ob, mat):
|
|
|
|
me = ob.data
|
|
me.materials.append(mat)
|
|
|
|
def ablength(x1 = 0.0, y1 = 0.0, z1 = 0.0, x2 = 0.0, y2 = 0.0, z2 = 0.0):
|
|
return sqrt( (x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2 )
|
|
|
|
##------------------------------------------------------------
|
|
# calculates the matrix for the new object
|
|
# depending on user pref
|
|
def align_matrix(context, location):
|
|
|
|
loc = Matrix.Translation(location)
|
|
obj_align = context.preferences.edit.object_align
|
|
if (context.space_data.type == 'VIEW_3D'
|
|
and obj_align == 'VIEW'):
|
|
rot = context.space_data.region_3d.view_matrix.to_3x3().inverted().to_4x4()
|
|
else:
|
|
rot = Matrix()
|
|
align_matrix = loc @ rot
|
|
|
|
return align_matrix
|
|
|
|
##------------------------------------------------------------
|
|
#### Curve creation functions
|
|
# sets bezierhandles to auto
|
|
def setBezierHandles(obj, mode = 'VECTOR'):
|
|
|
|
view_layer = bpy.context.view_layer
|
|
if obj.type != 'CURVE':
|
|
return
|
|
view_layer.objects.active = obj
|
|
bpy.ops.object.mode_set(mode = 'EDIT', toggle = True)
|
|
bpy.ops.curve.select_all(action = 'SELECT')
|
|
bpy.ops.curve.handle_type_set(type = mode)
|
|
bpy.ops.object.mode_set(mode = 'OBJECT', toggle = True)
|
|
view_layer.update()
|
|
|
|
##------------------------------------------------------------
|
|
#### Add units
|
|
def addUnits(stext, units):
|
|
scale = bpy.context.scene.unit_settings.scale_length
|
|
unit_system = bpy.context.scene.unit_settings.system
|
|
separate_units = bpy.context.scene.unit_settings.use_separate
|
|
if unit_system == 'METRIC':
|
|
if units == 'None': scale_steps = 1
|
|
if units == '\u00b5m': scale_steps = 1000000
|
|
if units == 'mm': scale_steps = 1000
|
|
if units == 'cm': scale_steps = 100
|
|
if units == 'm': scale_steps = 1
|
|
if units == 'km': scale_steps = 1/1000
|
|
if units == 'thou': scale_steps = 36000 * 1.0936133
|
|
if units == '"': scale_steps = 36 * 1.0936133
|
|
if units == '\'': scale_steps = 3 * 1.0936133
|
|
if units == 'yd': scale_steps = 1 * 1.0936133
|
|
if units == 'mi': scale_steps = 1/1760 * 1.0936133
|
|
dval = stext * scale_steps * scale
|
|
elif unit_system == 'IMPERIAL':
|
|
if units == 'None': scale_steps = 3 * 1.0936133
|
|
if units == '\u00b5m': scale_steps = 1000000
|
|
if units == 'mm': scale_steps = 1000
|
|
if units == 'cm': scale_steps = 100
|
|
if units == 'm': scale_steps = 1
|
|
if units == 'km': scale_steps = 1/1000
|
|
if units == 'thou': scale_steps = 36000 * 1.0936133
|
|
if units == '"': scale_steps = 36 * 1.0936133
|
|
if units == '\'': scale_steps = 3 * 1.0936133
|
|
if units == 'yd': scale_steps = 1 * 1.0936133
|
|
if units == 'mi': scale_steps = 1/1760 * 1.0936133
|
|
dval = stext * scale_steps * scale
|
|
else:
|
|
dval = stext
|
|
return dval
|
|
##------------------------------------------------------------
|
|
# create new CurveObject from vertarray and splineType
|
|
def createCurve(vertArray, self, align_matrix):
|
|
# options to vars
|
|
name = self.Dimension_Type # Type as name
|
|
|
|
# create curve
|
|
newCurve = bpy.data.curves.new(name, type = 'CURVE') # curvedatablock
|
|
newSpline = newCurve.splines.new('BEZIER') # spline
|
|
|
|
newSpline.bezier_points.add(int(len(vertArray) * 0.333333333))
|
|
newSpline.bezier_points.foreach_set('co', vertArray)
|
|
|
|
# set curveOptions
|
|
newCurve.dimensions = '2D'
|
|
newCurve.fill_mode = 'BOTH'
|
|
newSpline.use_cyclic_u = True
|
|
newSpline.use_endpoint_u = True
|
|
|
|
# create object with newCurve
|
|
DimensionCurve = bpy.data.objects.new(name, newCurve) # object
|
|
bpy.context.collection.objects.link(DimensionCurve) # place in active scene
|
|
DimensionCurve["Dimension"] = True
|
|
DimensionCurve.matrix_world = align_matrix # apply matrix
|
|
self.Dimension_Name = DimensionCurve.name
|
|
|
|
# creat DimensionText and rotation
|
|
w = 1
|
|
if self.Dimension_width < 0 :
|
|
w = -1
|
|
l = 1
|
|
if self.Dimension_length < 0 :
|
|
l = -1
|
|
|
|
x = self.Dimension_width / 2
|
|
y = self.Dimension_length + l * self.Dimension_dsize / 2 + self.Dimension_depth / 2 + self.Dimension_textdepth
|
|
|
|
gettextround = int(self.Dimension_textround)
|
|
stext = addUnits(self.Dimension_width, self.Dimension_units)
|
|
stext = abs(round(stext, gettextround))
|
|
if gettextround == 0:
|
|
stext = abs(int(stext))
|
|
|
|
align = 'CENTER'
|
|
offset_y = 0
|
|
|
|
if self.Dimension_Type == 'Linear-2':
|
|
y = self.Dimension_depth / 2 + self.Dimension_textdepth
|
|
|
|
if self.Dimension_Type == 'Radius':
|
|
x = self.Dimension_width + w * self.Dimension_dsize / 2 + w * abs(self.Dimension_length) / 2
|
|
y = self.Dimension_depth / 2 + self.Dimension_textdepth
|
|
|
|
if self.Dimension_Type == 'Diameter':
|
|
x = 0
|
|
y = self.Dimension_depth / 2 + self.Dimension_textdepth
|
|
|
|
g = hypot(x, y)
|
|
c = self.Dimension_startlocation
|
|
u = asin(y / g)
|
|
if self.Dimension_width < 0 :
|
|
u = radians(180) - u
|
|
xx = cos(u) * g
|
|
yy = sin(u) * g
|
|
|
|
stext = str(stext)
|
|
if self.Dimension_units != 'None' and self.Dimension_add_units_name:
|
|
stext += self.Dimension_units
|
|
|
|
if self.Dimension_Type == 'Angular1' or self.Dimension_Type == 'Angular2' or self.Dimension_Type == 'Angular3':
|
|
xx = cos(radians(self.Dimension_angle / 2)) * (self.Dimension_width + w * self.Dimension_depth / 2 + w * self.Dimension_textdepth)
|
|
yy = sin(radians(self.Dimension_angle / 2)) * (self.Dimension_width + w * self.Dimension_depth / 2 + w * self.Dimension_textdepth)
|
|
system_rotation = bpy.context.scene.unit_settings.system_rotation
|
|
if system_rotation == 'DEGREES':
|
|
stext = abs(round(self.Dimension_angle, gettextround))
|
|
if gettextround == 0:
|
|
stext = abs(int(stext))
|
|
stext = str(stext) + '°'
|
|
else:
|
|
stext = abs(round(self.Dimension_angle * pi / 180, gettextround))
|
|
if gettextround == 0:
|
|
stext = abs(int(stext))
|
|
stext = str(stext)
|
|
align = 'LEFT'
|
|
if self.Dimension_XYZType == 'BOTTOM' or self.Dimension_XYZType == 'BACK' or self.Dimension_XYZType == 'LEFT':
|
|
align = 'RIGHT'
|
|
if self.Dimension_width < 0 :
|
|
offset_y = 0
|
|
align = 'RIGHT'
|
|
if self.Dimension_XYZType == 'BOTTOM' or self.Dimension_XYZType == 'BACK' or self.Dimension_XYZType == 'LEFT':
|
|
align = 'LEFT'
|
|
|
|
if self.Dimension_Type == 'Note':
|
|
if cos(radians(self.Dimension_angle)) > 0:
|
|
xx = cos(radians(self.Dimension_angle)) * (self.Dimension_width) + l * w * self.Dimension_depth / 2 + l * w * self.Dimension_textdepth
|
|
yy = sin(radians(self.Dimension_angle)) * (self.Dimension_width) + w * self.Dimension_depth / 2 + w * self.Dimension_textdepth
|
|
stext = self.Dimension_note
|
|
align = 'LEFT'
|
|
if self.Dimension_XYZType == 'BOTTOM' or self.Dimension_XYZType == 'BACK' or self.Dimension_XYZType == 'LEFT':
|
|
align = 'RIGHT'
|
|
if self.Dimension_width < 0 :
|
|
align = 'RIGHT'
|
|
xx = cos(radians(self.Dimension_angle)) * (self.Dimension_width) + l * w * self.Dimension_depth / 2 + l * w * self.Dimension_textdepth
|
|
yy = sin(radians(self.Dimension_angle)) * (self.Dimension_width) - w * self.Dimension_depth / 2 - w * self.Dimension_textdepth
|
|
if self.Dimension_XYZType == 'BOTTOM' or self.Dimension_XYZType == 'BACK' or self.Dimension_XYZType == 'LEFT':
|
|
align = 'LEFT'
|
|
else:
|
|
xx = cos(radians(self.Dimension_angle)) * (self.Dimension_width) - l * w * self.Dimension_depth / 2 - l * w * self.Dimension_textdepth
|
|
yy = sin(radians(self.Dimension_angle)) * (self.Dimension_width) + w * self.Dimension_depth / 2 + w * self.Dimension_textdepth
|
|
stext = self.Dimension_note
|
|
align = 'RIGHT'
|
|
if self.Dimension_XYZType == 'BOTTOM' or self.Dimension_XYZType == 'BACK' or self.Dimension_XYZType == 'LEFT':
|
|
align = 'LEFT'
|
|
if self.Dimension_width < 0 :
|
|
align = 'LEFT'
|
|
xx = cos(radians(self.Dimension_angle)) * (self.Dimension_width) - l * w * self.Dimension_depth / 2 - l * w * self.Dimension_textdepth
|
|
yy = sin(radians(self.Dimension_angle)) * (self.Dimension_width) - w * self.Dimension_depth / 2 - w * self.Dimension_textdepth
|
|
if self.Dimension_XYZType == 'BOTTOM' or self.Dimension_XYZType == 'BACK' or self.Dimension_XYZType == 'LEFT':
|
|
align = 'RIGHT'
|
|
|
|
if self.Dimension_liberty == '2D':
|
|
tv = Vector((xx, yy, 0))
|
|
|
|
DimensionText = addText(stext, tv, self.Dimension_textsize, align, offset_y, self.Dimension_font)
|
|
|
|
if self.Dimension_XYZType == 'TOP' or self.Dimension_XYZType == 'BOTTOM':
|
|
DimensionCurve.rotation_euler[0] = radians(0)
|
|
DimensionCurve.rotation_euler[1] = radians(0)
|
|
if self.Dimension_XYType == 'X':
|
|
DimensionCurve.rotation_euler[2] = radians(self.Dimension_rotation)
|
|
DimensionCurve.location[1] += self.Dimension_offset
|
|
if self.Dimension_XYType == 'Y':
|
|
DimensionCurve.rotation_euler[2] = radians(90+self.Dimension_rotation)
|
|
DimensionCurve.location[0] += self.Dimension_offset
|
|
|
|
if self.Dimension_XYZType == 'FRONT' or self.Dimension_XYZType == 'BACK':
|
|
DimensionCurve.rotation_euler[0] = radians(90)
|
|
if self.Dimension_XZType == 'X':
|
|
DimensionCurve.rotation_euler[1] = -radians(self.Dimension_rotation)
|
|
DimensionCurve.location[1] += self.Dimension_offset
|
|
if self.Dimension_XZType == 'Z':
|
|
DimensionCurve.rotation_euler[1] = -radians(90+self.Dimension_rotation)
|
|
DimensionCurve.location[0] += self.Dimension_offset
|
|
DimensionCurve.rotation_euler[2] = radians(0)
|
|
|
|
if self.Dimension_XYZType == 'RIGHT' or self.Dimension_XYZType == 'LEFT':
|
|
DimensionCurve.rotation_euler[0] = radians(90)
|
|
if self.Dimension_YZType == 'Y':
|
|
DimensionCurve.rotation_euler[1] = -radians(self.Dimension_rotation)
|
|
DimensionCurve.location[0] += self.Dimension_offset
|
|
if self.Dimension_YZType == 'Z':
|
|
DimensionCurve.rotation_euler[1] = -radians(90+self.Dimension_rotation)
|
|
DimensionCurve.location[1] += self.Dimension_offset
|
|
DimensionCurve.rotation_euler[2] = radians(90)
|
|
|
|
if self.Dimension_XYZType == 'TOP' or self.Dimension_XYZType == 'FRONT' or self.Dimension_XYZType == 'RIGHT':
|
|
DimensionText.rotation_euler[1] = radians(0)
|
|
if self.Dimension_XYZType == 'BOTTOM' or self.Dimension_XYZType == 'BACK' or self.Dimension_XYZType == 'LEFT':
|
|
DimensionText.rotation_euler[1] = radians(180)
|
|
|
|
if self.Dimension_width_or_location == 'location':
|
|
if self.Dimension_Type == 'Angular1' or self.Dimension_Type == 'Angular2' or self.Dimension_Type == 'Angular3':
|
|
vx = self.Dimension_endlocation.x - self.Dimension_startlocation.x
|
|
vy = self.Dimension_endlocation.y - self.Dimension_startlocation.y
|
|
vz = self.Dimension_endlocation.z - self.Dimension_startlocation.z
|
|
if self.Dimension_XYZType == 'TOP' or self.Dimension_XYZType == 'BOTTOM':
|
|
g = hypot(vx, vy)
|
|
if g != 0 :
|
|
u2 = acos(vx / g)
|
|
u1 = asin(vy / g)
|
|
if u1 < 0 :
|
|
u2 = u1
|
|
else:
|
|
u2 = 0
|
|
DimensionCurve.rotation_euler[2] = u2
|
|
|
|
if self.Dimension_XYZType == 'FRONT' or self.Dimension_XYZType == 'BACK':
|
|
g = hypot(vx, vz)
|
|
if g != 0 :
|
|
u2 = acos(vx / g)
|
|
u1 = asin(vz / g)
|
|
if u1 < 0 :
|
|
u2 = u1
|
|
else:
|
|
u2 = 0
|
|
DimensionCurve.rotation_euler[1] = -u2
|
|
|
|
if self.Dimension_XYZType == 'RIGHT' or self.Dimension_XYZType == 'LEFT':
|
|
g = hypot(vy, vz)
|
|
if g != 0 :
|
|
u2 = acos(vy / g)
|
|
u1 = asin(vz / g)
|
|
if u1 < 0 :
|
|
u2 = u1
|
|
else:
|
|
u2 = 0
|
|
DimensionCurve.rotation_euler[1] = -u2
|
|
|
|
if self.Dimension_liberty == '3D':
|
|
tv = Vector((xx, yy, 0))
|
|
DimensionText = addText(stext, tv, self.Dimension_textsize, align, offset_y, self.Dimension_font)
|
|
v = self.Dimension_endlocation - self.Dimension_startlocation
|
|
if v.length != 0 :
|
|
u1 = -asin(v[2] / v.length)
|
|
else:
|
|
u1 = 0
|
|
g = hypot(v[0], v[1])
|
|
if g != 0 :
|
|
u2 = asin(v[1] / g)
|
|
if self.Dimension_endlocation.x < self.Dimension_startlocation.x :
|
|
u2 = radians(180)-asin(v[1] / g)
|
|
else:
|
|
u2 = 0
|
|
|
|
DimensionCurve.rotation_euler[0] = radians(self.Dimension_rotation)
|
|
DimensionCurve.rotation_euler[1] = u1
|
|
DimensionCurve.rotation_euler[2] = u2
|
|
|
|
# Align to view
|
|
if self.Dimension_align_to_camera :
|
|
obj_camera = bpy.context.scene.camera
|
|
DimensionCurve.rotation_euler[0] = obj_camera.rotation_euler[0]
|
|
DimensionCurve.rotation_euler[1] = obj_camera.rotation_euler[1]
|
|
DimensionCurve.rotation_euler[2] = obj_camera.rotation_euler[2]
|
|
|
|
# set materials
|
|
if self.Dimension_matname in bpy.data.materials :
|
|
setMaterial(DimensionCurve, bpy.data.materials[self.Dimension_matname])
|
|
setMaterial(DimensionText, bpy.data.materials[self.Dimension_matname])
|
|
else:
|
|
red = makeMaterial(self.Dimension_matname, (1, 0, 0, 0), (1, 0, 0), 1)
|
|
setMaterial(DimensionCurve, red)
|
|
setMaterial(DimensionText, red)
|
|
|
|
setBezierHandles(DimensionCurve, 'VECTOR')
|
|
setBezierHandles(DimensionText, 'VECTOR')
|
|
|
|
group_name = 'Dimensions'
|
|
|
|
bpy.ops.object.mode_set(mode = 'OBJECT')
|
|
|
|
if group_name in bpy.data.collections:
|
|
group = bpy.data.collections[group_name]
|
|
else:
|
|
group = bpy.data.collections.new(group_name)
|
|
|
|
if not DimensionCurve.name in group.objects:
|
|
group.objects.link(DimensionCurve)
|
|
|
|
if not DimensionText.name in group.objects:
|
|
group.objects.link(DimensionText)
|
|
|
|
DimensionText.parent = DimensionCurve
|
|
|
|
if self.Dimension_appoint_parent and not self.Dimension_parent == '':
|
|
const = DimensionCurve.constraints.new(type='CHILD_OF')
|
|
const.target = bpy.data.objects[self.Dimension_parent]
|
|
const.inverse_matrix = bpy.data.objects[self.Dimension_parent].matrix_world.inverted()
|
|
bpy.context.view_layer.update()
|
|
|
|
bpy.ops.object.select_all(action='DESELECT')
|
|
DimensionCurve.select_set(True)
|
|
DimensionText.select_set(True)
|
|
bpy.context.view_layer.objects.active = DimensionCurve
|
|
bpy.context.view_layer.update()
|
|
|
|
DimensionCurve["Dimension_Name"] = self.Dimension_Name
|
|
DimensionCurve["Dimension_Type"] = self.Dimension_Type
|
|
DimensionCurve["Dimension_XYZType"] = self.Dimension_XYZType
|
|
DimensionCurve["Dimension_XYType"] = self.Dimension_XYType
|
|
DimensionCurve["Dimension_XZType"] = self.Dimension_XZType
|
|
DimensionCurve["Dimension_YZType"] = self.Dimension_YZType
|
|
DimensionCurve["Dimension_startlocation"] = c
|
|
DimensionCurve["Dimension_endlocation"] = self.Dimension_endlocation
|
|
DimensionCurve["Dimension_endanglelocation"] = self.Dimension_endanglelocation
|
|
DimensionCurve["Dimension_width_or_location"] = self.Dimension_width_or_location
|
|
DimensionCurve["Dimension_liberty"] = self.Dimension_liberty
|
|
DimensionCurve["Dimension_Change"] = False
|
|
|
|
#### Dimension properties
|
|
DimensionCurve["Dimension_resolution"] = self.Dimension_resolution
|
|
DimensionCurve["Dimension_width"] = self.Dimension_width
|
|
DimensionCurve["Dimension_length"] = self.Dimension_length
|
|
DimensionCurve["Dimension_dsize"] = self.Dimension_dsize
|
|
DimensionCurve["Dimension_depth"] = self.Dimension_depth
|
|
DimensionCurve["Dimension_depth_from_center"] = self.Dimension_depth_from_center
|
|
DimensionCurve["Dimension_angle"] = self.Dimension_angle
|
|
DimensionCurve["Dimension_rotation"] = self.Dimension_rotation
|
|
DimensionCurve["Dimension_offset"] = self.Dimension_offset
|
|
|
|
#### Dimension text properties
|
|
DimensionCurve["Dimension_textsize"] = self.Dimension_textsize
|
|
DimensionCurve["Dimension_textdepth"] = self.Dimension_textdepth
|
|
DimensionCurve["Dimension_textround"] = self.Dimension_textround
|
|
DimensionCurve["Dimension_font"] = self.Dimension_font
|
|
|
|
#### Dimension Arrow properties
|
|
DimensionCurve["Dimension_arrow"] = self.Dimension_arrow
|
|
DimensionCurve["Dimension_arrowdepth"] = self.Dimension_arrowdepth
|
|
DimensionCurve["Dimension_arrowlength"] = self.Dimension_arrowlength
|
|
|
|
#### Materials properties
|
|
DimensionCurve["Dimension_matname"] = self.Dimension_matname
|
|
|
|
#### Note properties
|
|
DimensionCurve["Dimension_note"] = self.Dimension_note
|
|
DimensionCurve["Dimension_align_to_camera"] = self.Dimension_align_to_camera
|
|
|
|
#### Parent
|
|
DimensionCurve["Dimension_parent"] = self.Dimension_parent
|
|
DimensionCurve["Dimension_appoint_parent"] = self.Dimension_appoint_parent
|
|
|
|
#### Units
|
|
DimensionCurve["Dimension_units"] = self.Dimension_units
|
|
DimensionCurve["Dimension_add_units_name"] = self.Dimension_add_units_name
|
|
|
|
return
|
|
|
|
##------------------------------------------------------------
|
|
# Main Function
|
|
def main(self, align_matrix):
|
|
# deselect all objects
|
|
bpy.ops.object.select_all(action = 'DESELECT')
|
|
|
|
# options
|
|
Type = self.Dimension_Type
|
|
|
|
if self.Dimension_width_or_location == 'location':
|
|
if self.Dimension_liberty == '2D':
|
|
if self.Dimension_XYZType == 'TOP':
|
|
if self.Dimension_XYType == 'X':
|
|
self.Dimension_width = self.Dimension_endlocation[0] - self.Dimension_startlocation[0]
|
|
if self.Dimension_XYType == 'Y':
|
|
self.Dimension_width = self.Dimension_endlocation[1] - self.Dimension_startlocation[1]
|
|
if self.Dimension_XYZType == 'FRONT':
|
|
if self.Dimension_XZType == 'X':
|
|
self.Dimension_width = self.Dimension_endlocation[0] - self.Dimension_startlocation[0]
|
|
if self.Dimension_XZType == 'Z':
|
|
self.Dimension_width = self.Dimension_endlocation[2] - self.Dimension_startlocation[2]
|
|
if self.Dimension_XYZType == 'RIGHT':
|
|
if self.Dimension_YZType == 'Y':
|
|
self.Dimension_width = self.Dimension_endlocation[1] - self.Dimension_startlocation[1]
|
|
if self.Dimension_YZType == 'Z':
|
|
self.Dimension_width = self.Dimension_endlocation[2] - self.Dimension_startlocation[2]
|
|
if self.Dimension_XYZType == 'BOTTOM':
|
|
if self.Dimension_XYType == 'X':
|
|
self.Dimension_width = self.Dimension_endlocation[0] - self.Dimension_startlocation[0]
|
|
if self.Dimension_XYType == 'Y':
|
|
self.Dimension_width = self.Dimension_endlocation[1] - self.Dimension_startlocation[1]
|
|
if self.Dimension_XYZType == 'BACK':
|
|
if self.Dimension_XZType == 'X':
|
|
self.Dimension_width = self.Dimension_endlocation[0] - self.Dimension_startlocation[0]
|
|
if self.Dimension_XZType == 'Z':
|
|
self.Dimension_width = self.Dimension_endlocation[2] - self.Dimension_startlocation[2]
|
|
if self.Dimension_XYZType == 'LEFT':
|
|
if self.Dimension_YZType == 'Y':
|
|
self.Dimension_width = self.Dimension_endlocation[1] - self.Dimension_startlocation[1]
|
|
if self.Dimension_YZType == 'Z':
|
|
self.Dimension_width = self.Dimension_endlocation[2] - self.Dimension_startlocation[2]
|
|
if self.Dimension_liberty == '3D':
|
|
v = self.Dimension_endlocation - self.Dimension_startlocation
|
|
self.Dimension_width = v.length
|
|
|
|
if Type == 'Angular1' or Type == 'Angular2' or Type == 'Angular3':
|
|
a = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, self.Dimension_startlocation.z, self.Dimension_endlocation.x, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
b = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, self.Dimension_startlocation.z, self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z)
|
|
c = ablength(self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z, self.Dimension_endlocation.x, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
self.Dimension_width = max(a, b, c)
|
|
if self.Dimension_XYZType == 'TOP' or self.Dimension_XYZType == 'BOTTOM':
|
|
if self.Angle_Type == 'A':
|
|
c = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, 0, self.Dimension_endlocation.x, self.Dimension_endlocation.y, 0)
|
|
b = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, 0, self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, 0)
|
|
a = ablength(self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z, self.Dimension_endlocation.x, self.Dimension_endlocation.y, 0)
|
|
if self.Angle_Type == 'B':
|
|
a = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, 0, self.Dimension_endlocation.x, self.Dimension_endlocation.y, 0)
|
|
c = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, 0, self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, 0)
|
|
b = ablength(self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z, self.Dimension_endlocation.x, self.Dimension_endlocation.y, 0)
|
|
if self.Angle_Type == 'C':
|
|
b = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, 0, self.Dimension_endlocation.x, self.Dimension_endlocation.y, 0)
|
|
a = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, 0, self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, 0)
|
|
c = ablength(self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z, self.Dimension_endlocation.x, self.Dimension_endlocation.y, 0)
|
|
if self.Dimension_XYZType == 'FRONT' or self.Dimension_XYZType == 'BACK':
|
|
if self.Angle_Type == 'A':
|
|
c = ablength(self.Dimension_startlocation.x, 0, self.Dimension_startlocation.z, self.Dimension_endlocation.x, 0, self.Dimension_endlocation.z)
|
|
b = ablength(self.Dimension_startlocation.x, 0, self.Dimension_startlocation.z, self.Dimension_endanglelocation.x, 0, self.Dimension_endanglelocation.z)
|
|
a = ablength(self.Dimension_endanglelocation.x, 0, self.Dimension_endanglelocation.z, self.Dimension_endlocation.x, 0, self.Dimension_endlocation.z)
|
|
if self.Angle_Type == 'B':
|
|
a = ablength(self.Dimension_startlocation.x, 0, self.Dimension_startlocation.z, self.Dimension_endlocation.x, 0, self.Dimension_endlocation.z)
|
|
c = ablength(self.Dimension_startlocation.x, 0, self.Dimension_startlocation.z, self.Dimension_endanglelocation.x, 0, self.Dimension_endanglelocation.z)
|
|
b = ablength(self.Dimension_endanglelocation.x, 0, self.Dimension_endanglelocation.z, self.Dimension_endlocation.x, 0, self.Dimension_endlocation.z)
|
|
if self.Angle_Type == 'C':
|
|
b = ablength(self.Dimension_startlocation.x, 0, self.Dimension_startlocation.z, self.Dimension_endlocation.x, 0, self.Dimension_endlocation.z)
|
|
a = ablength(self.Dimension_startlocation.x, 0, self.Dimension_startlocation.z, self.Dimension_endanglelocation.x, 0, self.Dimension_endanglelocation.z)
|
|
c = ablength(self.Dimension_endanglelocation.x, 0, self.Dimension_endanglelocation.z, self.Dimension_endlocation.x, 0, self.Dimension_endlocation.z)
|
|
if self.Dimension_XYZType == 'RIGHT' or self.Dimension_XYZType == 'LEFT':
|
|
if self.Angle_Type == 'A':
|
|
c = ablength(0, self.Dimension_startlocation.y, self.Dimension_startlocation.z, 0, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
b = ablength(0, self.Dimension_startlocation.y, self.Dimension_startlocation.z, 0, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z)
|
|
a = ablength(0, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z, 0, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
if self.Angle_Type == 'B':
|
|
a = ablength(0, self.Dimension_startlocation.y, self.Dimension_startlocation.z, 0, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
c = ablength(0, self.Dimension_startlocation.y, self.Dimension_startlocation.z, 0, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z)
|
|
b = ablength(0, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z, 0, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
if self.Angle_Type == 'C':
|
|
b = ablength(0, self.Dimension_startlocation.y, self.Dimension_startlocation.z, 0, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
a = ablength(0, self.Dimension_startlocation.y, self.Dimension_startlocation.z, 0, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z)
|
|
c = ablength(0, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z, 0, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
if self.Dimension_liberty == '3D':
|
|
if self.Angle_Type == 'A':
|
|
c = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, self.Dimension_startlocation.z, self.Dimension_endlocation.x, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
b = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, self.Dimension_startlocation.z, self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z)
|
|
a = ablength(self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z, self.Dimension_endlocation.x, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
if self.Angle_Type == 'B':
|
|
a = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, self.Dimension_startlocation.z, self.Dimension_endlocation.x, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
c = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, self.Dimension_startlocation.z, self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z)
|
|
b = ablength(self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z, self.Dimension_endlocation.x, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
if self.Angle_Type == 'C':
|
|
b = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, self.Dimension_startlocation.z, self.Dimension_endlocation.x, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
a = ablength(self.Dimension_startlocation.x, self.Dimension_startlocation.y, self.Dimension_startlocation.z, self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z)
|
|
c = ablength(self.Dimension_endanglelocation.x, self.Dimension_endanglelocation.y, self.Dimension_endanglelocation.z, self.Dimension_endlocation.x, self.Dimension_endlocation.y, self.Dimension_endlocation.z)
|
|
if b != 0 and c != 0 :
|
|
self.Dimension_angle = degrees(acos((b**2 + c**2 - a**2)/(2*b*c)))
|
|
else:
|
|
self.Dimension_angle = 0
|
|
|
|
#
|
|
if self.Dimension_width == 0:
|
|
return {'FINISHED'}
|
|
|
|
# get verts
|
|
if Type == 'Linear-1':
|
|
verts = Linear1(self.Dimension_width,
|
|
self.Dimension_length,
|
|
self.Dimension_dsize,
|
|
self.Dimension_depth,
|
|
self.Dimension_depth_from_center,
|
|
self.Dimension_arrow,
|
|
self.Dimension_arrowdepth,
|
|
self.Dimension_arrowlength)
|
|
|
|
if Type == 'Linear-2':
|
|
verts = Linear2(self.Dimension_width,
|
|
self.Dimension_dsize,
|
|
self.Dimension_depth,
|
|
self.Dimension_depth_from_center,
|
|
self.Dimension_arrow,
|
|
self.Dimension_arrowdepth,
|
|
self.Dimension_arrowlength)
|
|
|
|
if Type == 'Linear-3':
|
|
verts = Linear3(self.Dimension_width,
|
|
self.Dimension_length,
|
|
self.Dimension_dsize,
|
|
self.Dimension_depth,
|
|
self.Dimension_depth_from_center,
|
|
self.Dimension_arrow,
|
|
self.Dimension_arrowdepth,
|
|
self.Dimension_arrowlength)
|
|
|
|
if Type == 'Radius':
|
|
verts = Radius(self.Dimension_width,
|
|
self.Dimension_length,
|
|
self.Dimension_dsize,
|
|
self.Dimension_depth,
|
|
self.Dimension_depth_from_center,
|
|
self.Dimension_arrow,
|
|
self.Dimension_arrowdepth,
|
|
self.Dimension_arrowlength)
|
|
|
|
if Type == 'Diameter':
|
|
verts = Diameter(self.Dimension_width,
|
|
self.Dimension_length,
|
|
self.Dimension_dsize,
|
|
self.Dimension_depth,
|
|
self.Dimension_depth_from_center,
|
|
self.Dimension_arrow,
|
|
self.Dimension_arrowdepth,
|
|
self.Dimension_arrowlength)
|
|
|
|
if Type == 'Angular1':
|
|
if self.Dimension_angle == 0:
|
|
return {'FINISHED'}
|
|
verts = Angular1(self.Dimension_width,
|
|
self.Dimension_length,
|
|
self.Dimension_depth,
|
|
self.Dimension_angle,
|
|
self.Dimension_resolution,
|
|
self.Dimension_depth_from_center,
|
|
self.Dimension_arrow,
|
|
self.Dimension_arrowdepth,
|
|
self.Dimension_arrowlength)
|
|
|
|
if Type == 'Angular2':
|
|
if self.Dimension_angle == 0:
|
|
return {'FINISHED'}
|
|
verts = Angular2(self.Dimension_width,
|
|
self.Dimension_depth,
|
|
self.Dimension_angle,
|
|
self.Dimension_resolution,
|
|
self.Dimension_arrow,
|
|
self.Dimension_arrowdepth,
|
|
self.Dimension_arrowlength)
|
|
|
|
if Type == 'Angular3':
|
|
if self.Dimension_angle == 0:
|
|
return {'FINISHED'}
|
|
verts = Angular3(self.Dimension_width,
|
|
self.Dimension_length,
|
|
self.Dimension_dsize,
|
|
self.Dimension_depth,
|
|
self.Dimension_angle,
|
|
self.Dimension_resolution,
|
|
self.Dimension_depth_from_center,
|
|
self.Dimension_arrow,
|
|
self.Dimension_arrowdepth,
|
|
self.Dimension_arrowlength)
|
|
|
|
if Type == 'Note':
|
|
verts = Note(self.Dimension_width,
|
|
self.Dimension_length,
|
|
self.Dimension_depth,
|
|
self.Dimension_angle,
|
|
self.Dimension_arrow,
|
|
self.Dimension_arrowdepth,
|
|
self.Dimension_arrowlength)
|
|
|
|
vertArray = []
|
|
# turn verts into array
|
|
for v in verts:
|
|
vertArray += v
|
|
|
|
# create object
|
|
createCurve(vertArray, self, align_matrix)
|
|
|
|
return
|
|
|
|
#### Delete dimension group
|
|
def DimensionDelete(self, context):
|
|
|
|
bpy.context.view_layer.update()
|
|
bpy.ops.object.mode_set(mode = 'OBJECT')
|
|
|
|
bpy.ops.object.select_grouped(extend=True, type='CHILDREN_RECURSIVE')
|
|
bpy.ops.object.delete()
|
|
bpy.context.view_layer.update()
|
|
|
|
return
|
|
|
|
class Dimension(bpy.types.Operator):
|
|
''''''
|
|
bl_idname = "curve.dimension"
|
|
bl_label = "Dimension"
|
|
bl_options = {'REGISTER', 'UNDO', 'PRESET'}
|
|
bl_description = "add dimension"
|
|
|
|
#settings : bpy.props.PointerProperty(type=DimensionVariables)
|
|
|
|
# align_matrix for the invoke
|
|
align_matrix : Matrix()
|
|
|
|
Dimension : BoolProperty(name = "Dimension",
|
|
default = True,
|
|
description = "dimension")
|
|
|
|
#### change properties
|
|
Dimension_Name : StringProperty(name = "Name",
|
|
description = "Name")
|
|
|
|
Dimension_Change : BoolProperty(name = "Change",
|
|
default = False,
|
|
description = "change dimension")
|
|
|
|
Dimension_Delete : StringProperty(name = "Delete",
|
|
description = "Delete dimension")
|
|
|
|
#### general properties
|
|
Types = [('Linear-1', 'Linear-1', 'Linear-1'),
|
|
('Linear-2', 'Linear-2', 'Linear-2'),
|
|
('Linear-3', 'Linear-3', 'Linear-3'),
|
|
('Radius', 'Radius', 'Radius'),
|
|
('Diameter', 'Diameter', 'Diameter'),
|
|
('Angular1', 'Angular1', 'Angular1'),
|
|
('Angular2', 'Angular2', 'Angular2'),
|
|
('Angular3', 'Angular3', 'Angular3'),
|
|
('Note', 'Note', 'Note')]
|
|
Dimension_Type : EnumProperty(name = "Type",
|
|
description = "Form of Curve to create",
|
|
items = Types)
|
|
ATypes = [('A', 'A', 'A'),
|
|
('B', 'B', 'B'),
|
|
('C', 'C', 'C')]
|
|
Angle_Type : EnumProperty(name = "Angle",
|
|
description = "Select corne ABC",
|
|
items = ATypes)
|
|
XYZTypes = [
|
|
('TOP', 'Top', 'TOP'),
|
|
('FRONT', 'Front', 'FRONT'),
|
|
('RIGHT', 'Right', 'RIGHT'),
|
|
('BOTTOM', 'Bottom', 'BOTTOM'),
|
|
('BACK', 'Back', 'BACK'),
|
|
('LEFT', 'Left', 'LEFT')]
|
|
Dimension_XYZType : EnumProperty(name = "Coordinate system",
|
|
description = "Place in a coordinate system",
|
|
items = XYZTypes)
|
|
XYTypes = [
|
|
('X', 'X', 'X'),
|
|
('Y', 'Y', 'Y')]
|
|
Dimension_XYType : EnumProperty(name = "XY",
|
|
description = "XY",
|
|
items = XYTypes)
|
|
XZTypes = [
|
|
('X', 'X', 'X'),
|
|
('Z', 'Z', 'Z')]
|
|
Dimension_XZType : EnumProperty(name = "XZ",
|
|
description = "XZ",
|
|
items = XZTypes)
|
|
YZTypes = [
|
|
('Y', 'Y', 'Y'),
|
|
('Z', 'Z', 'Z')]
|
|
Dimension_YZType : EnumProperty(name = "YZ",
|
|
description = "YZ",
|
|
items = YZTypes)
|
|
Dimension_startlocation : FloatVectorProperty(name = "",
|
|
description = "Start location",
|
|
default = (0.0, 0.0, 0.0),
|
|
subtype = 'XYZ')
|
|
Dimension_endlocation : FloatVectorProperty(name = "",
|
|
description = "End location",
|
|
default = (2.0, 2.0, 2.0),
|
|
subtype = 'XYZ')
|
|
Dimension_endanglelocation : FloatVectorProperty(name = "",
|
|
description = "End angle location",
|
|
default = (4.0, 4.0, 4.0),
|
|
subtype = 'XYZ')
|
|
width_or_location_items = [
|
|
('width', 'width', 'width'),
|
|
('location', 'location', 'location')]
|
|
Dimension_width_or_location : EnumProperty(name = "width or location",
|
|
items = width_or_location_items,
|
|
description = "width or location")
|
|
libertyItems = [
|
|
('2D', '2D', '2D'),
|
|
('3D', '3D', '3D')]
|
|
Dimension_liberty : EnumProperty(name = "2D / 3D",
|
|
items = libertyItems,
|
|
description = "2D or 3D Dimension")
|
|
|
|
### Arrow
|
|
Arrows = [
|
|
('Arrow1', 'Arrow1', 'Arrow1'),
|
|
('Arrow2', 'Arrow2', 'Arrow2'),
|
|
('Serifs1', 'Serifs1', 'Serifs1'),
|
|
('Serifs2', 'Serifs2', 'Serifs2'),
|
|
('Without', 'Without', 'Without')]
|
|
Dimension_arrow : EnumProperty(name = "Arrow",
|
|
items = Arrows,
|
|
description = "Arrow")
|
|
Dimension_arrowdepth : FloatProperty(name = "Depth",
|
|
default = 0.1,
|
|
min = 0, soft_min = 0,
|
|
description = "Arrow depth")
|
|
Dimension_arrowlength : FloatProperty(name = "Length",
|
|
default = 0.25,
|
|
min = 0, soft_min = 0,
|
|
description = "Arrow length")
|
|
|
|
#### Dimension properties
|
|
Dimension_resolution : IntProperty(name = "Resolution",
|
|
default = 10,
|
|
min = 1, soft_min = 1,
|
|
description = "Resolution")
|
|
Dimension_width : FloatProperty(name = "Width",
|
|
default = 2,
|
|
unit = 'LENGTH',
|
|
description = "Width")
|
|
Dimension_length : FloatProperty(name = "Length",
|
|
default = 2,
|
|
description = "Length")
|
|
Dimension_dsize : FloatProperty(name = "Size",
|
|
default = 1,
|
|
min = 0, soft_min = 0,
|
|
description = "Size")
|
|
Dimension_depth : FloatProperty(name = "Depth",
|
|
default = 0.1,
|
|
min = 0, soft_min = 0,
|
|
description = "Depth")
|
|
Dimension_depth_from_center : BoolProperty(name = "Depth from center",
|
|
default = False,
|
|
description = "Depth from center")
|
|
Dimension_angle : FloatProperty(name = "Angle",
|
|
default = 45,
|
|
description = "Angle")
|
|
Dimension_rotation : FloatProperty(name = "Rotation",
|
|
default = 0,
|
|
description = "Rotation")
|
|
Dimension_offset : FloatProperty(name = "Offset",
|
|
default = 0,
|
|
description = "Offset")
|
|
|
|
#### Dimension units properties
|
|
Units = [
|
|
('None', 'None', 'None'),
|
|
('\u00b5m', '\u00b5m', '\u00b5m'),
|
|
('mm', 'mm', 'mm'),
|
|
('cm', 'cm', 'cm'),
|
|
('m', 'm', 'm'),
|
|
('km', 'km', 'km'),
|
|
('thou', 'thou', 'thou'),
|
|
('"', '"', '"'),
|
|
('\'', '\'', '\''),
|
|
('yd', 'yd', 'yd'),
|
|
('mi', 'mi', 'mi')]
|
|
Dimension_units : EnumProperty(name = "Units",
|
|
items = Units,
|
|
description = "Units")
|
|
Dimension_add_units_name : BoolProperty(name = "Add units name",
|
|
default = False,
|
|
description = "Add units name")
|
|
|
|
#### Dimension text properties
|
|
Dimension_textsize : FloatProperty(name = "Size",
|
|
default = 1,
|
|
description = "Size")
|
|
Dimension_textdepth : FloatProperty(name = "Depth",
|
|
default = 0.2,
|
|
description = "Depth")
|
|
Dimension_textround : IntProperty(name = "Rounding",
|
|
default = 2,
|
|
min = 0, soft_min = 0,
|
|
description = "Rounding")
|
|
Dimension_font : StringProperty(name = "Font",
|
|
default = '',
|
|
subtype = 'FILE_PATH',
|
|
description = "Font")
|
|
|
|
#### Materials properties
|
|
Dimension_matname : StringProperty(name = "Name",
|
|
default = 'Dimension_Red',
|
|
description = "Material name")
|
|
|
|
#### Note properties
|
|
Dimension_note : StringProperty(name = "Note",
|
|
default = 'Note',
|
|
description = "Note text")
|
|
Dimension_align_to_camera : BoolProperty(name = "Align to camera",
|
|
default = False,
|
|
description = "Align to camera")
|
|
|
|
TMP_startlocation : FloatVectorProperty(name = "",
|
|
description = "Start location",
|
|
default = (0.0, 0.0, 0.0),
|
|
subtype = 'XYZ')
|
|
TMP_endlocation : FloatVectorProperty(name = "",
|
|
description = "Start location",
|
|
default = (2.0, 2.0, 2.0),
|
|
subtype = 'XYZ')
|
|
TMP_endanglelocation : FloatVectorProperty(name = "",
|
|
description = "Start location",
|
|
default = (4.0, 4.0, 4.0),
|
|
subtype = 'XYZ')
|
|
#### Parent
|
|
Dimension_parent : StringProperty(name = "Parent",
|
|
default = '',
|
|
description = "Parent")
|
|
Dimension_appoint_parent : BoolProperty(name = "Appoint parent",
|
|
default = False,
|
|
description = "Appoint parent")
|
|
|
|
##### DRAW #####
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
# general options
|
|
col = layout.column()
|
|
col.prop(self, 'Dimension_Type')
|
|
|
|
# options per Type Linear-1(width = 2, length = 2, dsize = 1, depth = 0.1)
|
|
if self.Dimension_Type == 'Linear-1':
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_width_or_location', expand = True)
|
|
col = layout.column()
|
|
col.label(text = "End location:")
|
|
row = layout.row()
|
|
if self.Dimension_width_or_location == 'width':
|
|
row.prop(self, 'Dimension_width')
|
|
else:
|
|
row.prop(self, 'Dimension_endlocation')
|
|
box = layout.box()
|
|
box.label(text="Options")
|
|
box.prop(self, 'Dimension_length')
|
|
box.prop(self, 'Dimension_dsize')
|
|
box.prop(self, 'Dimension_depth')
|
|
box.prop(self, 'Dimension_depth_from_center')
|
|
box.prop(self, 'Dimension_rotation')
|
|
box.prop(self, 'Dimension_offset')
|
|
|
|
# options per Type Linear-2(width = 2, dsize = 1, depth = 0.1)
|
|
if self.Dimension_Type == 'Linear-2':
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_width_or_location', expand = True)
|
|
col = layout.column()
|
|
col.label(text = "End location:")
|
|
row = layout.row()
|
|
if self.Dimension_width_or_location == 'width':
|
|
row.prop(self, 'Dimension_width')
|
|
else:
|
|
row.prop(self, 'Dimension_endlocation')
|
|
box = layout.box()
|
|
box.label(text="Options")
|
|
box.prop(self, 'Dimension_dsize')
|
|
box.prop(self, 'Dimension_depth')
|
|
box.prop(self, 'Dimension_rotation')
|
|
box.prop(self, 'Dimension_offset')
|
|
|
|
# options per Type Linear-3(width = 2, length = 2, dsize = 1, depth = 0.1)
|
|
if self.Dimension_Type == 'Linear-3':
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_width_or_location', expand = True)
|
|
col = layout.column()
|
|
col.label(text = "End location:")
|
|
row = layout.row()
|
|
if self.Dimension_width_or_location == 'width':
|
|
row.prop(self, 'Dimension_width')
|
|
else:
|
|
row.prop(self, 'Dimension_endlocation')
|
|
box = layout.box()
|
|
box.label(text="Options")
|
|
box.prop(self, 'Dimension_length')
|
|
box.prop(self, 'Dimension_dsize')
|
|
box.prop(self, 'Dimension_depth')
|
|
box.prop(self, 'Dimension_depth_from_center')
|
|
box.prop(self, 'Dimension_rotation')
|
|
box.prop(self, 'Dimension_offset')
|
|
|
|
# options per Type Radius(width = 2, length = 2, dsize = 1, depth = 0.1)
|
|
if self.Dimension_Type == 'Radius':
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_width_or_location', expand = True)
|
|
col = layout.column()
|
|
col.label(text = "End location:")
|
|
row = layout.row()
|
|
if self.Dimension_width_or_location == 'width':
|
|
row.prop(self, 'Dimension_width')
|
|
else:
|
|
row.prop(self, 'Dimension_endlocation')
|
|
box = layout.box()
|
|
box.label(text="Options")
|
|
box.prop(self, 'Dimension_length')
|
|
box.prop(self, 'Dimension_dsize')
|
|
box.prop(self, 'Dimension_depth')
|
|
box.prop(self, 'Dimension_rotation')
|
|
|
|
# options per Type Diameter(width = 2, length = 2, dsize = 1, depth = 0.1)
|
|
if self.Dimension_Type == 'Diameter':
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_width_or_location', expand = True)
|
|
col = layout.column()
|
|
col.label(text = "End location:")
|
|
row = layout.row()
|
|
if self.Dimension_width_or_location == 'width':
|
|
row.prop(self, 'Dimension_width')
|
|
else:
|
|
row.prop(self, 'Dimension_endlocation')
|
|
box = layout.box()
|
|
box.label(text="Options")
|
|
box.prop(self, 'Dimension_length')
|
|
box.prop(self, 'Dimension_dsize')
|
|
box.prop(self, 'Dimension_depth')
|
|
box.prop(self, 'Dimension_rotation')
|
|
|
|
# options per Type Angular1(width = 2, dsize = 1, depth = 0.1, angle = 45)
|
|
if self.Dimension_Type == 'Angular1':
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_width_or_location', expand = True)
|
|
col = layout.column()
|
|
col.label(text = "End location:")
|
|
row = layout.row()
|
|
if self.Dimension_width_or_location == 'width':
|
|
row.prop(self, 'Dimension_angle')
|
|
else:
|
|
row.prop(self, 'Dimension_endlocation')
|
|
col = layout.column()
|
|
col.label(text = "End angle location:")
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_endanglelocation')
|
|
row = layout.row()
|
|
row.prop(self, 'Angle_Type')
|
|
box = layout.box()
|
|
box.label(text="Options")
|
|
box.prop(self, 'Dimension_width')
|
|
box.prop(self, 'Dimension_length')
|
|
box.prop(self, 'Dimension_depth')
|
|
box.prop(self, 'Dimension_depth_from_center')
|
|
box.prop(self, 'Dimension_rotation')
|
|
box.prop(self, 'Dimension_resolution')
|
|
|
|
# options per Type Angular2(width = 2, dsize = 1, depth = 0.1, angle = 45)
|
|
if self.Dimension_Type == 'Angular2':
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_width_or_location', expand = True)
|
|
col = layout.column()
|
|
col.label(text = "End location:")
|
|
row = layout.row()
|
|
if self.Dimension_width_or_location == 'width':
|
|
row.prop(self, 'Dimension_angle')
|
|
else:
|
|
row.prop(self, 'Dimension_endlocation')
|
|
col = layout.column()
|
|
col.label(text = "End angle location:")
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_endanglelocation')
|
|
row = layout.row()
|
|
row.prop(self, 'Angle_Type')
|
|
box = layout.box()
|
|
box.label(text="Options")
|
|
box.prop(self, 'Dimension_width')
|
|
box.prop(self, 'Dimension_depth')
|
|
box.prop(self, 'Dimension_rotation')
|
|
box.prop(self, 'Dimension_resolution')
|
|
|
|
# options per Type Angular3(width = 2, dsize = 1, depth = 0.1, angle = 45)
|
|
if self.Dimension_Type == 'Angular3':
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_width_or_location', expand = True)
|
|
col = layout.column()
|
|
col.label(text = "End location:")
|
|
row = layout.row()
|
|
if self.Dimension_width_or_location == 'width':
|
|
row.prop(self, 'Dimension_angle')
|
|
else:
|
|
row.prop(self, 'Dimension_endlocation')
|
|
col = layout.column()
|
|
col.label(text = "End angle location:")
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_endanglelocation')
|
|
row = layout.row()
|
|
row.prop(self, 'Angle_Type')
|
|
box = layout.box()
|
|
box.label(text="Options")
|
|
box.prop(self, 'Dimension_width')
|
|
box.prop(self, 'Dimension_length')
|
|
box.prop(self, 'Dimension_dsize')
|
|
box.prop(self, 'Dimension_depth')
|
|
box.prop(self, 'Dimension_depth_from_center')
|
|
box.prop(self, 'Dimension_rotation')
|
|
box.prop(self, 'Dimension_resolution')
|
|
|
|
# options per Type Note(width = 2, length = 2, dsize = 1, depth = 0.1)
|
|
if self.Dimension_Type == 'Note':
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_width_or_location', expand = True)
|
|
col = layout.column()
|
|
col.label(text = "End location:")
|
|
row = layout.row()
|
|
if self.Dimension_width_or_location == 'width':
|
|
row.prop(self, 'Dimension_width')
|
|
else:
|
|
row.prop(self, 'Dimension_endlocation')
|
|
box = layout.box()
|
|
box.label(text="Options")
|
|
box.prop(self, 'Dimension_length')
|
|
box.prop(self, 'Dimension_depth')
|
|
box.prop(self, 'Dimension_angle')
|
|
box.prop(self, 'Dimension_rotation')
|
|
box.prop(self, 'Dimension_note')
|
|
box.prop(self, 'Dimension_offset')
|
|
|
|
col = layout.column()
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_align_to_camera')
|
|
col = layout.column()
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_liberty', expand = True)
|
|
|
|
if self.Dimension_liberty == '2D':
|
|
col = layout.column()
|
|
col.label(text="Coordinate system")
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_XYZType', expand = True)
|
|
if self.Dimension_XYZType == 'TOP' or self.Dimension_XYZType == 'BOTTOM':
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_XYType', expand = True)
|
|
if self.Dimension_XYZType == 'FRONT' or self.Dimension_XYZType == 'BACK':
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_XZType', expand = True)
|
|
if self.Dimension_XYZType == 'RIGHT' or self.Dimension_XYZType == 'LEFT':
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_YZType', expand = True)
|
|
|
|
col = layout.column()
|
|
col.label(text="Start location:")
|
|
row = layout.row()
|
|
row.prop(self, 'Dimension_startlocation')
|
|
|
|
box = layout.box()
|
|
box.prop(self, 'Dimension_units')
|
|
box.prop(self, 'Dimension_add_units_name')
|
|
|
|
if not self.Dimension_parent == '':
|
|
box = layout.box()
|
|
box.prop(self, 'Dimension_appoint_parent')
|
|
|
|
box = layout.box()
|
|
box.label(text="Text Options")
|
|
box.prop(self, 'Dimension_textsize')
|
|
box.prop(self, 'Dimension_textdepth')
|
|
box.prop(self, 'Dimension_textround')
|
|
box.prop(self, 'Dimension_font')
|
|
|
|
box = layout.box()
|
|
box.label(text="Arrow Options")
|
|
box.prop(self, 'Dimension_arrow')
|
|
box.prop(self, 'Dimension_arrowdepth')
|
|
box.prop(self, 'Dimension_arrowlength')
|
|
|
|
box = layout.box()
|
|
box.label(text="Material Option")
|
|
box.prop(self, 'Dimension_matname')
|
|
|
|
##### POLL #####
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return context.scene != None
|
|
|
|
##### EXECUTE #####
|
|
def execute(self, context):
|
|
|
|
if self.Dimension_Change:
|
|
DimensionDelete(self, context)
|
|
|
|
#go to object mode
|
|
if bpy.ops.object.mode_set.poll():
|
|
bpy.ops.object.mode_set(mode = 'OBJECT')
|
|
bpy.context.view_layer.update()
|
|
|
|
# main function
|
|
self.align_matrix = align_matrix(context, self.Dimension_startlocation)
|
|
main(self, self.align_matrix)
|
|
|
|
return {'FINISHED'}
|
|
|
|
##### INVOKE #####
|
|
def invoke(self, context, event):
|
|
bpy.context.view_layer.update()
|
|
if self.Dimension_Change:
|
|
bpy.context.scene.cursor.location = self.Dimension_startlocation
|
|
else:
|
|
if self.Dimension_width_or_location == 'width':
|
|
self.Dimension_startlocation = bpy.context.scene.cursor.location
|
|
|
|
if self.Dimension_width_or_location == 'location':
|
|
if (self.Dimension_endlocation[2] - self.Dimension_startlocation[2]) != 0 :
|
|
self.Dimension_XYZType = 'FRONT'
|
|
self.Dimension_XZType = 'Z'
|
|
if (self.Dimension_endlocation[1] - self.Dimension_startlocation[1]) != 0 :
|
|
self.Dimension_XYZType = 'TOP'
|
|
self.Dimension_XYType = 'Y'
|
|
if (self.Dimension_endlocation[0] - self.Dimension_startlocation[0]) != 0 :
|
|
self.Dimension_XYZType = 'TOP'
|
|
self.Dimension_XYType = 'X'
|
|
|
|
self.align_matrix = align_matrix(context, self.Dimension_startlocation)
|
|
|
|
self.execute(context)
|
|
|
|
return {'FINISHED'}
|
|
|
|
#location update
|
|
def StartLocationUpdate(self, context):
|
|
|
|
bpy.context.scene.cursor.location = self.Dimension_startlocation
|
|
|
|
return
|
|
|
|
# ### MENU append ###
|
|
def Dimension_object_menu(self, context):
|
|
bl_label = 'Dimension'
|
|
|
|
obj = context.object
|
|
layout = self.layout
|
|
|
|
if 'Dimension' in obj.keys():
|
|
props = layout.operator("curve.dimension", text="Change Dimension")
|
|
props.Dimension_Change = True
|
|
props.Dimension_Delete = obj.name
|
|
props.Dimension_width_or_location = obj["Dimension_width_or_location"]
|
|
props.Dimension_startlocation = obj.location
|
|
props.Dimension_endlocation = obj["Dimension_endlocation"]
|
|
props.Dimension_endanglelocation = obj["Dimension_endanglelocation"]
|
|
props.Dimension_liberty = obj["Dimension_liberty"]
|
|
props.Dimension_Type = obj["Dimension_Type"]
|
|
props.Dimension_XYZType = obj["Dimension_XYZType"]
|
|
props.Dimension_XYType = obj["Dimension_XYType"]
|
|
props.Dimension_XZType = obj["Dimension_XZType"]
|
|
props.Dimension_YZType = obj["Dimension_YZType"]
|
|
props.Dimension_resolution = obj["Dimension_resolution"]
|
|
props.Dimension_width = obj["Dimension_width"]
|
|
props.Dimension_length = obj["Dimension_length"]
|
|
props.Dimension_dsize = obj["Dimension_dsize"]
|
|
props.Dimension_depth = obj["Dimension_depth"]
|
|
props.Dimension_depth_from_center = obj["Dimension_depth_from_center"]
|
|
props.Dimension_angle = obj["Dimension_angle"]
|
|
props.Dimension_rotation = obj["Dimension_rotation"]
|
|
props.Dimension_offset = 0
|
|
props.Dimension_textsize = obj["Dimension_textsize"]
|
|
props.Dimension_textdepth = obj["Dimension_textdepth"]
|
|
props.Dimension_textround = obj["Dimension_textround"]
|
|
props.Dimension_font = obj["Dimension_font"]
|
|
props.Dimension_matname = obj["Dimension_matname"]
|
|
props.Dimension_note = obj["Dimension_note"]
|
|
props.Dimension_align_to_camera = obj["Dimension_align_to_camera"]
|
|
props.Dimension_arrow = obj["Dimension_arrow"]
|
|
props.Dimension_arrowdepth = obj["Dimension_arrowdepth"]
|
|
props.Dimension_arrowlength = obj["Dimension_arrowlength"]
|
|
props.Dimension_parent = obj["Dimension_parent"]
|
|
props.Dimension_appoint_parent = obj["Dimension_appoint_parent"]
|
|
props.Dimension_units = obj["Dimension_units"]
|
|
props.Dimension_add_units_name = obj["Dimension_add_units_name"]
|
|
layout.separator()
|
|
|
|
vertex = []
|
|
for obj in context.selected_objects :
|
|
if obj.type == 'MESH':
|
|
for i in obj.data.vertices :
|
|
if i.select :
|
|
vertex.append(obj.matrix_world @ i.co)
|
|
|
|
if obj.type == 'CURVE':
|
|
for i in obj.data.splines :
|
|
for j in i.bezier_points :
|
|
if j.select_control_point :
|
|
vertex.append(obj.matrix_world @ j.co)
|
|
|
|
if len(vertex) == 1:
|
|
startvertex = vertex[0]
|
|
endvertex = bpy.context.scene.cursor.location
|
|
props1 = layout.operator("curve.dimension", text = 'Add linear note')
|
|
props1.Dimension_Change = False
|
|
props1.Dimension_Type = 'Note'
|
|
props1.Dimension_width_or_location = 'location'
|
|
props1.Dimension_startlocation = startvertex
|
|
props1.Dimension_liberty = '2D'
|
|
props1.Dimension_rotation = 0
|
|
props1.Dimension_parent = obj.name
|
|
|
|
props2 = layout.operator("curve.dimension", text = 'Add 3D note')
|
|
props2.Dimension_Change = False
|
|
props2.Dimension_Type = 'Note'
|
|
props2.Dimension_width_or_location = 'location'
|
|
props2.Dimension_startlocation = startvertex
|
|
props2.Dimension_liberty = '3D'
|
|
props2.Dimension_rotation = 0
|
|
props2.Dimension_parent = obj.name
|
|
|
|
props3 = layout.operator("curve.dimension", text = 'Add linear dimension')
|
|
props3.Dimension_Change = False
|
|
props3.Dimension_Type = 'Linear-1'
|
|
props3.Dimension_width_or_location = 'location'
|
|
props3.Dimension_startlocation = endvertex
|
|
props3.Dimension_endlocation = startvertex
|
|
props3.Dimension_liberty = '2D'
|
|
props3.Dimension_rotation = 0
|
|
props3.Dimension_parent = obj.name
|
|
|
|
props4 = layout.operator("curve.dimension", text = 'Add 3D dimension')
|
|
props4.Dimension_Change = False
|
|
props4.Dimension_Type = 'Linear-1'
|
|
props4.Dimension_width_or_location = 'location'
|
|
props4.Dimension_startlocation = endvertex
|
|
props4.Dimension_endlocation = startvertex
|
|
props4.Dimension_liberty = '3D'
|
|
props4.Dimension_rotation = 0
|
|
props4.Dimension_parent = obj.name
|
|
|
|
props7 = layout.operator("curve.dimension", text = 'Add linear radius')
|
|
props7.Dimension_Change = False
|
|
props7.Dimension_Type = 'Radius'
|
|
props7.Dimension_width_or_location = 'location'
|
|
props7.Dimension_startlocation = endvertex
|
|
props7.Dimension_endlocation = startvertex
|
|
props7.Dimension_liberty = '2D'
|
|
props7.Dimension_rotation = 0
|
|
props7.Dimension_parent = obj.name
|
|
|
|
props8 = layout.operator("curve.dimension", text = 'Add 3D radius')
|
|
props8.Dimension_Change = False
|
|
props8.Dimension_Type = 'Radius'
|
|
props8.Dimension_width_or_location = 'location'
|
|
props8.Dimension_startlocation = endvertex
|
|
props8.Dimension_endlocation = startvertex
|
|
props8.Dimension_liberty = '3D'
|
|
props8.Dimension_rotation = 0
|
|
props8.Dimension_parent = obj.name
|
|
|
|
props9 = layout.operator("curve.dimension", text = 'Add linear diameter')
|
|
props9.Dimension_Change = False
|
|
props9.Dimension_Type = 'Diameter'
|
|
props9.Dimension_width_or_location = 'location'
|
|
props9.Dimension_startlocation = endvertex
|
|
props9.Dimension_endlocation = startvertex
|
|
props9.Dimension_liberty = '2D'
|
|
props9.Dimension_rotation = 0
|
|
props9.Dimension_parent = obj.name
|
|
|
|
props10 = layout.operator("curve.dimension", text = 'Add 3D diameter')
|
|
props10.Dimension_Change = False
|
|
props10.Dimension_Type = 'Diameter'
|
|
props10.Dimension_width_or_location = 'location'
|
|
props10.Dimension_startlocation = endvertex
|
|
props10.Dimension_endlocation = startvertex
|
|
props10.Dimension_liberty = '3D'
|
|
props10.Dimension_rotation = 0
|
|
props10.Dimension_parent = obj.name
|
|
|
|
if len(vertex) == 2:
|
|
startvertex = vertex[0]
|
|
endvertex = vertex[1]
|
|
if endvertex[0] < startvertex[0]:
|
|
startvertex = vertex[1]
|
|
endvertex = vertex[0]
|
|
|
|
props1 = layout.operator("curve.dimension", text = 'Add linear dimension')
|
|
props1.Dimension_Change = False
|
|
props1.Dimension_Type = 'Linear-1'
|
|
props1.Dimension_width_or_location = 'location'
|
|
props1.Dimension_startlocation = startvertex
|
|
props1.Dimension_endlocation = endvertex
|
|
props1.Dimension_liberty = '2D'
|
|
props1.Dimension_rotation = 0
|
|
props1.Dimension_parent = obj.name
|
|
|
|
props2 = layout.operator("curve.dimension", text = 'Add 3D dimension')
|
|
props2.Dimension_Change = False
|
|
props2.Dimension_Type = 'Linear-1'
|
|
props2.Dimension_width_or_location = 'location'
|
|
props2.Dimension_startlocation = startvertex
|
|
props2.Dimension_endlocation = endvertex
|
|
props2.Dimension_liberty = '3D'
|
|
props2.Dimension_rotation = 0
|
|
props2.Dimension_parent = obj.name
|
|
|
|
props3 = layout.operator("curve.dimension", text = 'Add linear radius')
|
|
props3.Dimension_Change = False
|
|
props3.Dimension_Type = 'Radius'
|
|
props3.Dimension_width_or_location = 'location'
|
|
props3.Dimension_startlocation = startvertex
|
|
props3.Dimension_endlocation = endvertex
|
|
props3.Dimension_liberty = '2D'
|
|
props3.Dimension_rotation = 0
|
|
props3.Dimension_parent = obj.name
|
|
|
|
props4 = layout.operator("curve.dimension", text = 'Add 3D radius')
|
|
props4.Dimension_Change = False
|
|
props4.Dimension_Type = 'Radius'
|
|
props4.Dimension_width_or_location = 'location'
|
|
props4.Dimension_startlocation = startvertex
|
|
props4.Dimension_endlocation = endvertex
|
|
props4.Dimension_liberty = '3D'
|
|
props4.Dimension_rotation = 0
|
|
props4.Dimension_parent = obj.name
|
|
|
|
props5 = layout.operator("curve.dimension", text = 'Add linear diameter')
|
|
props5.Dimension_Change = False
|
|
props5.Dimension_Type = 'Diameter'
|
|
props5.Dimension_width_or_location = 'location'
|
|
props5.Dimension_startlocation = startvertex
|
|
props5.Dimension_endlocation = endvertex
|
|
props5.Dimension_liberty = '2D'
|
|
props5.Dimension_rotation = 0
|
|
props5.Dimension_parent = obj.name
|
|
|
|
props6 = layout.operator("curve.dimension", text = 'Add 3D diameter')
|
|
props6.Dimension_Change = False
|
|
props6.Dimension_Type = 'Diameter'
|
|
props6.Dimension_width_or_location = 'location'
|
|
props6.Dimension_startlocation = startvertex
|
|
props6.Dimension_endlocation = endvertex
|
|
props6.Dimension_liberty = '3D'
|
|
props6.Dimension_rotation = 0
|
|
props6.Dimension_parent = obj.name
|
|
|
|
if len(vertex) == 3:
|
|
startvertex = vertex[0]
|
|
endvertex = vertex[1]
|
|
endanglevertex = vertex[2]
|
|
if endvertex[0] < startvertex[0]:
|
|
startvertex = vertex[1]
|
|
endvertex = vertex[0]
|
|
|
|
props1 = layout.operator("curve.dimension", text = 'Add Linear angle dimension')
|
|
props1.Dimension_Change = False
|
|
props1.Dimension_Type = 'Angular1'
|
|
props1.Dimension_width_or_location = 'location'
|
|
props1.Dimension_startlocation = startvertex
|
|
props1.Dimension_endlocation = endvertex
|
|
props1.Dimension_endanglelocation = endanglevertex
|
|
props1.Dimension_liberty = '2D'
|
|
props1.Dimension_rotation = 0
|
|
props1.Dimension_parent = obj.name
|
|
|
|
props2 = layout.operator("curve.dimension", text = 'Add 3D angle dimension')
|
|
props2.Dimension_Change = False
|
|
props2.Dimension_Type = 'Angular1'
|
|
props2.Dimension_width_or_location = 'location'
|
|
props2.Dimension_startlocation = startvertex
|
|
props2.Dimension_endlocation = endvertex
|
|
props2.Dimension_endanglelocation = endanglevertex
|
|
props2.Dimension_liberty = '3D'
|
|
props2.Dimension_rotation = 0
|
|
props2.Dimension_parent = obj.name
|
|
|
|
def Dimension_edit_menu(self, context):
|
|
bl_label = 'Dimension'
|
|
|
|
obj = context.object
|
|
layout = self.layout
|
|
|
|
vertex = []
|
|
for i in obj.data.vertices :
|
|
if i.select :
|
|
vertex.append(obj.matrix_world @ i.co)
|
|
|
|
if len(vertex) == 1:
|
|
startvertex = vertex[0]
|
|
endvertex = bpy.context.scene.cursor.location
|
|
props1 = layout.operator("curve.dimension", text = 'Add linear note')
|
|
props1.Dimension_Change = False
|
|
props1.Dimension_Type = 'Note'
|
|
props1.Dimension_width_or_location = 'location'
|
|
props1.Dimension_startlocation = startvertex
|
|
props1.Dimension_liberty = '2D'
|
|
props1.Dimension_rotation = 0
|
|
props1.Dimension_parent = obj.name
|
|
|
|
props2 = layout.operator("curve.dimension", text = 'Add 3D note')
|
|
props2.Dimension_Change = False
|
|
props2.Dimension_Type = 'Note'
|
|
props2.Dimension_width_or_location = 'location'
|
|
props2.Dimension_startlocation = startvertex
|
|
props2.Dimension_liberty = '3D'
|
|
props2.Dimension_rotation = 0
|
|
props2.Dimension_parent = obj.name
|
|
|
|
props3 = layout.operator("curve.dimension", text = 'Add linear dimension')
|
|
props3.Dimension_Change = False
|
|
props3.Dimension_Type = 'Linear-1'
|
|
props3.Dimension_width_or_location = 'location'
|
|
props3.Dimension_startlocation = endvertex
|
|
props3.Dimension_endlocation = startvertex
|
|
props3.Dimension_liberty = '2D'
|
|
props3.Dimension_rotation = 0
|
|
props3.Dimension_parent = obj.name
|
|
|
|
props4 = layout.operator("curve.dimension", text = 'Add 3D dimension')
|
|
props4.Dimension_Change = False
|
|
props4.Dimension_Type = 'Linear-1'
|
|
props4.Dimension_width_or_location = 'location'
|
|
props4.Dimension_startlocation = endvertex
|
|
props4.Dimension_endlocation = startvertex
|
|
props4.Dimension_liberty = '3D'
|
|
props4.Dimension_rotation = 0
|
|
props4.Dimension_parent = obj.name
|
|
|
|
props7 = layout.operator("curve.dimension", text = 'Add linear radius')
|
|
props7.Dimension_Change = False
|
|
props7.Dimension_Type = 'Radius'
|
|
props7.Dimension_width_or_location = 'location'
|
|
props7.Dimension_startlocation = endvertex
|
|
props7.Dimension_endlocation = startvertex
|
|
props7.Dimension_liberty = '2D'
|
|
props7.Dimension_rotation = 0
|
|
props7.Dimension_parent = obj.name
|
|
|
|
props8 = layout.operator("curve.dimension", text = 'Add 3D radius')
|
|
props8.Dimension_Change = False
|
|
props8.Dimension_Type = 'Radius'
|
|
props8.Dimension_width_or_location = 'location'
|
|
props8.Dimension_startlocation = endvertex
|
|
props8.Dimension_endlocation = startvertex
|
|
props8.Dimension_liberty = '3D'
|
|
props8.Dimension_rotation = 0
|
|
props8.Dimension_parent = obj.name
|
|
|
|
props9 = layout.operator("curve.dimension", text = 'Add linear diameter')
|
|
props9.Dimension_Change = False
|
|
props9.Dimension_Type = 'Diameter'
|
|
props9.Dimension_width_or_location = 'location'
|
|
props9.Dimension_startlocation = endvertex
|
|
props9.Dimension_endlocation = startvertex
|
|
props9.Dimension_liberty = '2D'
|
|
props9.Dimension_rotation = 0
|
|
props9.Dimension_parent = obj.name
|
|
|
|
props10 = layout.operator("curve.dimension", text = 'Add 3D diameter')
|
|
props10.Dimension_Change = False
|
|
props10.Dimension_Type = 'Diameter'
|
|
props10.Dimension_width_or_location = 'location'
|
|
props10.Dimension_startlocation = endvertex
|
|
props10.Dimension_endlocation = startvertex
|
|
props10.Dimension_liberty = '3D'
|
|
props10.Dimension_rotation = 0
|
|
props10.Dimension_parent = obj.name
|
|
|
|
if len(vertex) == 2:
|
|
startvertex = vertex[0]
|
|
endvertex = vertex[1]
|
|
if endvertex[0] < startvertex[0]:
|
|
startvertex = vertex[1]
|
|
endvertex = vertex[0]
|
|
|
|
props1 = layout.operator("curve.dimension", text = 'Add linear dimension')
|
|
props1.Dimension_Change = False
|
|
props1.Dimension_Type = 'Linear-1'
|
|
props1.Dimension_width_or_location = 'location'
|
|
props1.Dimension_startlocation = startvertex
|
|
props1.Dimension_endlocation = endvertex
|
|
props1.Dimension_liberty = '2D'
|
|
props1.Dimension_rotation = 0
|
|
props1.Dimension_parent = obj.name
|
|
|
|
props2 = layout.operator("curve.dimension", text = 'Add 3D dimension')
|
|
props2.Dimension_Change = False
|
|
props2.Dimension_Type = 'Linear-1'
|
|
props2.Dimension_width_or_location = 'location'
|
|
props2.Dimension_startlocation = startvertex
|
|
props2.Dimension_endlocation = endvertex
|
|
props2.Dimension_liberty = '3D'
|
|
props2.Dimension_rotation = 0
|
|
props2.Dimension_parent = obj.name
|
|
|
|
props3 = layout.operator("curve.dimension", text = 'Add linear radius')
|
|
props3.Dimension_Change = False
|
|
props3.Dimension_Type = 'Radius'
|
|
props3.Dimension_width_or_location = 'location'
|
|
props3.Dimension_startlocation = startvertex
|
|
props3.Dimension_endlocation = endvertex
|
|
props3.Dimension_liberty = '2D'
|
|
props3.Dimension_rotation = 0
|
|
props3.Dimension_parent = obj.name
|
|
|
|
props4 = layout.operator("curve.dimension", text = 'Add 3D radius')
|
|
props4.Dimension_Change = False
|
|
props4.Dimension_Type = 'Radius'
|
|
props4.Dimension_width_or_location = 'location'
|
|
props4.Dimension_startlocation = startvertex
|
|
props4.Dimension_endlocation = endvertex
|
|
props4.Dimension_liberty = '3D'
|
|
props4.Dimension_rotation = 0
|
|
props4.Dimension_parent = obj.name
|
|
|
|
props5 = layout.operator("curve.dimension", text = 'Add linear diameter')
|
|
props5.Dimension_Change = False
|
|
props5.Dimension_Type = 'Diameter'
|
|
props5.Dimension_width_or_location = 'location'
|
|
props5.Dimension_startlocation = startvertex
|
|
props5.Dimension_endlocation = endvertex
|
|
props5.Dimension_liberty = '2D'
|
|
props5.Dimension_rotation = 0
|
|
props5.Dimension_parent = obj.name
|
|
|
|
props6 = layout.operator("curve.dimension", text = 'Add 3D diameter')
|
|
props6.Dimension_Change = False
|
|
props6.Dimension_Type = 'Diameter'
|
|
props6.Dimension_width_or_location = 'location'
|
|
props6.Dimension_startlocation = startvertex
|
|
props6.Dimension_endlocation = endvertex
|
|
props6.Dimension_liberty = '3D'
|
|
props6.Dimension_rotation = 0
|
|
props6.Dimension_parent = obj.name
|
|
|
|
if len(vertex) == 3:
|
|
startvertex = vertex[0]
|
|
endvertex = vertex[1]
|
|
endanglevertex = vertex[2]
|
|
if endvertex[0] < startvertex[0]:
|
|
startvertex = vertex[1]
|
|
endvertex = vertex[0]
|
|
|
|
props1 = layout.operator("curve.dimension", text = 'Add Linear angle dimension')
|
|
props1.Dimension_Change = False
|
|
props1.Dimension_Type = 'Angular1'
|
|
props1.Dimension_width_or_location = 'location'
|
|
props1.Dimension_startlocation = startvertex
|
|
props1.Dimension_endlocation = endvertex
|
|
props1.Dimension_endanglelocation = endanglevertex
|
|
props1.Dimension_liberty = '2D'
|
|
props1.Dimension_rotation = 0
|
|
props1.Dimension_parent = obj.name
|
|
|
|
props2 = layout.operator("curve.dimension", text = 'Add 3D angle dimension')
|
|
props2.Dimension_Change = False
|
|
props2.Dimension_Type = 'Angular1'
|
|
props2.Dimension_width_or_location = 'location'
|
|
props2.Dimension_startlocation = startvertex
|
|
props2.Dimension_endlocation = endvertex
|
|
props2.Dimension_endanglelocation = endanglevertex
|
|
props2.Dimension_liberty = '3D'
|
|
props2.Dimension_rotation = 0
|
|
props2.Dimension_parent = obj.name
|
|
|
|
def Dimension_button(self, context):
|
|
oper = self.layout.operator(Dimension.bl_idname, text = "Dimension", icon = "PLUGIN")
|
|
oper.Dimension_Change = False
|
|
oper.Dimension_width_or_location = 'width'
|
|
oper.Dimension_liberty = '2D'
|
|
|
|
################################################################################
|
|
##### REGISTER #####
|
|
classes = [
|
|
Dimension,
|
|
]
|
|
|
|
def register():
|
|
from bpy.utils import register_class
|
|
for cls in classes:
|
|
register_class(cls)
|
|
|
|
bpy.types.VIEW3D_MT_curve_add.append(Dimension_button)
|
|
bpy.types.VIEW3D_MT_object_context_menu.prepend(Dimension_object_menu)
|
|
bpy.types.VIEW3D_MT_edit_mesh_context_menu.append(Dimension_edit_menu)
|
|
|
|
def unregister():
|
|
bpy.types.VIEW3D_MT_edit_mesh_context_menu.remove(Dimension_edit_menu)
|
|
bpy.types.VIEW3D_MT_object_context_menu.remove(Dimension_object_menu)
|
|
bpy.types.VIEW3D_MT_curve_add.remove(Dimension_button)
|
|
|
|
from bpy.utils import unregister_class
|
|
for cls in reversed(classes):
|
|
unregister_class(cls)
|
|
|
|
if __name__ == "__main__":
|
|
register()
|