def orientObjAlongPolyPts(obj, pts, basePoint=(0, 0, 0), baseVect=(0, 1, 0)):
print('orient obj along poly points')
up = (0, 0, 1)
generatedObjects = []
for i in range(0, len(pts) - 1):
if i < (len(pts) - 2):
p0 = pts[i]
p1 = pts[i + 1]
p2 = pts[i + 2]
v1 = rs.VectorUnitize(p1 - p0)
v2 = rs.VectorUnitize(p2 - p1)
n1 = rs.VectorCrossProduct(v1, up)
n2 = rs.VectorCrossProduct(v2, up)
mid = rs.VectorAdd(n1, n2)
n = rs.VectorUnitize(mid)
else:
p0 = pts[i]
p1 = pts[i + 1]
v1 = rs.VectorUnitize(p1 - p0)
n = rs.VectorCrossProduct(v1, up)
rs.AddLine(p1, p1 + n)
a = rs.VectorAngle((0, 1, 0), n)
gen = rs.OrientObject(obj, [basePoint, basePoint + baseVect],
[p1, p1 + n], 1)
generatedObjects.append(gen)
#g=rs.AddGroup()
#groupObjects=rs.AddObjectsToGroup(generatedObjects,g)
return generatedObjects
def divEQCrvToPolyAD(crv,w=900,adjacentCrvs=None):
outpoly=PolyAD()
crvLen=rs.CurveLength(crv)
numDiv=crvLen/w
width=crvLen/round(numDiv)
pts=rs.DivideCurve(crv,numDiv,False,True)
#add to output
outpoly.points=pts
sharedNormals=[None,None]
if adjacentCrvs is not None:
sharedNormals=findSharedbisecNormals(crv,adjacentCrvs)
for i in range(0,len(pts)-2):
up=(0,0,1)
# direct direct_end
# (p0)-v1->(p1)-v2->(p2)
# |n_start |n |n_end
# V V V
p0=pts[i]
p1=pts[i+1]
p2=pts[i+2]
v1=rs.VectorUnitize(p1-p0)
v2=rs.VectorUnitize(p2-p1)
n1=rs.VectorCrossProduct(v1,up)
n2=rs.VectorCrossProduct(v2,up)
mid=rs.VectorAdd(n1,n2)
n=rs.VectorUnitize(mid)
direct=p1-p0
#add to output
outpoly.directions.append(direct)
if i==0:
if sharedNormals[0] is not None: n_start=sharedNormals[0]
else: n_start=rs.VectorCrossProduct(v1,up)
outpoly.normals.append(n_start)
#add to output
outpoly.normals.append(n)
if i==len(pts)-3:
if sharedNormals[1] is not None: n_end=sharedNormals[1]
else: n_end=rs.VectorCrossProduct(v2,up)
outpoly.normals.append(n_end)
direct_end=p2-p1
outpoly.directions.append(direct_end)
return outpoly
def __generate_form_levels(self, spine_curve):
crvdomain = rs.CurveDomain(spine_curve)
printedState = ""
crosssection_planes = []
crosssection_plane_nums = []
crosssections = []
t_step = (crvdomain[1] - crvdomain[0]) / (
self.object_properties["number_of_lofts"] - 1)
t = crvdomain[0]
for t in rs.frange(crvdomain[0], crvdomain[1], t_step):
if (self.emotion_properties["vertical_AR"][str(int(t + 1))] !=
None):
crvcurvature = rs.CurveCurvature(spine_curve, t)
crosssectionplane = None
if not crvcurvature:
crvPoint = rs.EvaluateCurve(spine_curve, t)
crvTangent = rs.CurveTangent(spine_curve, t)
crvPerp = (0, 0, 1)
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
printedState = printedState + str(crvNormal)
crosssectionplane = rs.PlaneFromNormal(
crvPoint, crvTangent)
if (t == 0):
crosssectionplane = rs.PlaneFromNormal([0, 0, 0],
[0, 0, 1])
else:
crvPoint = crvcurvature[0]
crvTangent = crvcurvature[1]
crvPerp = rs.VectorUnitize(crvcurvature[4])
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
printedState = printedState + str(crvNormal)
crosssectionplane = rs.PlaneFromNormal(
crvPoint, crvTangent, crvNormal)
if crosssectionplane:
crosssection_planes.append(crosssectionplane)
crosssection_plane_nums.append(str(int(t + 1)))
if len(crosssection_plane_nums) > 0:
last_element = crosssection_plane_nums.pop(
len(crosssection_plane_nums) - 1)
crosssection_plane_nums.insert(0, last_element)
for index in xrange(len(crosssection_plane_nums)):
crosssections.append(
self.__generate_individual_levels(
crosssection_planes[index],
crosssection_plane_nums[index]))
if not crosssections: return
crosssections.append(crosssections.pop(0))
rs.AddLoftSrf(crosssections,
closed=False,
loft_type=int(
round(self.emotion_properties["vertical_wrapping"])))
return crosssection_planes[0]
def curvePlnrNormalAtEnds(crv):
up = (0, 0, 1)
dom = rs.CurveDomain(crv)
t0 = dom[0]
t1 = dom[1]
pln0 = rs.CurvePerpFrame(crv, t0)
pln1 = rs.CurvePerpFrame(crv, t1)
n0 = rs.VectorCrossProduct(pln0.ZAxis, up)
n1 = rs.VectorCrossProduct(pln1.ZAxis, up)
return n0, n1
def drawBox( side, location, angle_degrees1, angle_degrees2):
"""画一个2D方块
参数:
side(double): 方块的长度, double
locaiton(tuple(double, double,double)): 方块中心的位置
angle_degrees1(double): xy平面旋转角度degree1
angle_degrees2(double): 到达位置后继续朝z轴方向旋转角度degree2
Returns:
guid
"""
corners = []
corners.append((-side/2,-side/2,0))
corners.append(( side/2,-side/2,0))
corners.append((side/2,side/2,0))
corners.append((-side/2,side/2,0))
corners.append((-side/2,-side/2,side))
corners.append((side/2,-side/2,side))
corners.append((side/2,side/2,side))
corners.append((-side/2,side/2,side))
obj = rs.AddBox(corners)
xform = rs.XformRotation2(angle_degrees1, (0,0,1), (0,0,0))
obj = rs.TransformObject( obj, xform, False )
vectorR1 = rs.VectorRotate( (1,0,0), angle_degrees1, (0,0,0))
vectorR2 = rs.VectorCrossProduct(vectorR1, (0,0,1))
xform = rs.XformRotation2(angle_degrees1, vectorR2, (0,0,0))
obj = rs.TransformObject( obj, xform, False )
xform = rs.XformTranslation( location)
obj = rs.TransformObject( obj, xform, False )
return obj
def MirrorX(lineIn, pIn):
pLine0 = lineIn[0]
pLine1 = lineIn[1]
normal = rs.VectorUnitize(
rs.VectorCrossProduct([0, 0, 1], rs.VectorSubtract(pLine1, pLine0)))
matrix = rs.XformMirror(pLine1, normal)
return rs.PointTransform(pIn, matrix)
def srfPlane(obj):
tempplane = trp.getSrfFrame(obj)
plane = rs.CreatePlane(
tempplane.Origin,
rs.VectorCrossProduct(tempplane.ZAxis,
rs.WorldXYPlane().ZAxis), tempplane.ZAxis)
return plane
def GetSolidAngle(a,b,c): a = rs.VectorUnitize(a) b = rs.VectorUnitize(b) c = rs.VectorUnitize(c) numer = rs.VectorDotProduct(rs.VectorCrossProduct(a,b),c) denom = 1 + rs.VectorDotProduct(a,b) + rs.VectorDotProduct(b,c) + rs.VectorDotProduct(c,a) angle = 2*math.atan2(numer, denom) return abs(angle)
def Orthogonal(vecIn):
vecIn = rs.VectorUnitize(vecIn)
# Pick any vector which isn't aligned to the input
otherVec = rs.coerce3dvector((1.0, 0.0, 0.0))
if abs(rs.VectorDotProduct(vecIn, otherVec)) > 0.99:
otherVec = rs.coerce3dvector((0.0, 1.0, 0.0))
# Create a unit length orthogonal to both the other one, and the original one
return rs.VectorUnitize(rs.VectorCrossProduct(vecIn, otherVec))
def cross_section_plane_curvature(self, curvature, prev_normal, prev_perp):
crvPoint = curvature[0]
crvTangent = curvature[1]
crvPerp = rs.VectorUnitize(curvature[4])
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
if prev_normal:
crvNormal = self.reverse_if_needed(crvNormal, prev_normal)
if prev_perp:
crvPerp = self.reverse_if_needed(crvPerp, prev_perp)
return rs.PlaneFromFrame(crvPoint, crvPerp, crvNormal)
def flatWorm():
curveObject = rs.GetObject("pick a backbone curve", 4, True, False)
samples = rs.GetInteger("# of crosssections", 100, 5)
bend_radius = rs.GetReal("bend radius", 0.5, 0.001) # r1
perp_radius = rs.GetReal("ribbon plan radius", 2.0, 0.001) #r2
crvDom = rs.CurveDomain(
curveObject
) # domain != length // why do we use domains? == "The domain is the set of all possible input values to the function that defines the curve or surface."
crossSections = [] # empty array to store sections
t_step = (crvDom[1] -
crvDom[0]) / samples # this is starting to be a pattern!
t = crvDom[0] # start pt for loop at the start of the line
for t in rs.frange(crvDom[0], crvDom[1],
t_step): # loop thru entire domain w/ floats
crvCurvature = rs.CurveCurvature(
curveObject, t
) # evaluate curve with a circle - gives 3d normals & gives radius info
crossSecPlane = None
if not crvCurvature:
crvPoint = rs.EvaluateCurve(curveObject, t)
crvTan = rs.CurveTangent(curveObject, t) # get tangent vector
crvPerp = (0, 0, 1)
crvNorm = rs.VectorCrossProduct(crvTan,
crvPerp) # = product of 2 vectors
crossSecPlane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNorm)
else:
crvPoint = crvCurvature[0]
crvTan = crvCurvature[1]
crvPerp = rs.VectorUnitize(crvCurvature[4])
crvNorm = rs.VectorCrossProduct(crvTan, crvPerp) # look up
crossSecPlane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNorm)
if crossSecPlane:
csec = rs.AddEllipse(
crossSecPlane, bend_radius, perp_radius
) # draw ellipse at tan/normal to point along curve with radii
crossSections.append(csec) # add ellipses to an array
t += t_step # step through domain
rs.AddLoftSrf(crossSections) # loft list of curves
rs.DeleteObjects(
crossSections) # delete original list of curves as cleanup
def FlatWorm():
curve_object = rs.GetObject("Pick a backbone curve", 4, True, False)
if not curve_object: return
samples = rs.GetInteger("Number of cross sections", 100, 5)
if not samples: return
bend_radius = rs.GetReal("Bend plane radius", 0.5, 0.001)
if not bend_radius: return
perp_radius = rs.GetReal("Ribbon plane radius", 2.0, 0.001)
if not perp_radius: return
crvdomain = rs.CurveDomain(curve_object)
crosssections = []
t_step = (crvdomain[1]-crvdomain[0])/samples
t = crvdomain[0]
while t<=crvdomain[1]:
crvcurvature = rs.CurveCurvature(curve_object, t)
crosssectionplane = None
if not crvcurvature:
crvPoint = rs.EvaluateCurve(curve_object, t)
crvTangent = rs.CurveTangent(curve_object, t)
crvPerp = (0,0,1)
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
crosssectionplane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNormal)
else:
crvPoint = crvcurvature[0]
crvTangent = crvcurvature[1]
crvPerp = rs.VectorUnitize(crvcurvature[4])
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
crosssectionplane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNormal)
if crosssectionplane:
csec = rs.AddEllipse(crosssectionplane, bend_radius, perp_radius)
crosssections.append(csec)
t += t_step
if not crosssections: return
rs.AddLoftSrf(crosssections)
rs.DeleteObjects(crosssections)
def BasisFromDirection(direction):
b2 = rs.VectorUnitize(direction)
for b in range(3):
b0 = UnitVector(b)
# At least one unit vector must meet this condition
inner = rs.VectorDotProduct(b0, b2)
if -0.5 < inner <= 0.5:
b0 = rs.VectorUnitize(b0 - b2 * inner)
b1 = rs.VectorCrossProduct(b2, b0)
return [b0, b1, b2]
return UnitBasis()
def light_from_upper_left(intensity, color):
vec_cam = vector_of_active_view_camera()
vec_up = rs.VectorUnitize(
rs.VectorCrossProduct(rs.VectorCrossProduct(vec_cam, (0, 0, 1)),
vec_cam))
if vec_up is None:
vec_up = rs.VectorUnitize(
rs.VectorCrossProduct(rs.VectorCrossProduct(vec_cam, (0, 1, 0)),
vec_cam))
vec_left = rs.VectorUnitize(rs.VectorCrossProduct(vec_up, vec_cam))
vec_light = rs.VectorAdd(vec_up, vec_left)
# turn a bit toward the camera
vec_cam = rs.VectorScale(rs.VectorUnitize(vec_cam), -0.25)
vec_light = rs.VectorAdd(vec_light, vec_cam)
lid = add_light(vec_light, (0, 0, 0), intensity, color)
#print("created a light {}".format(lid))
return lid
def point_on_plane_top(pt, plane):
testVect = plane.XAxis
if plane.XAxis.Z != 0:
testVect = plane.YAxis
pp1 = plane.Origin
pp2 = pp1 + testVect
v1 = pp1 - pt
v2 = pp2 - pt
n = rs.VectorCrossProduct(v1, v2)
return n.Z > 0
def offset_vector(self, point, cross_section_index, point_index):
modulo = len(self.point_lists[cross_section_index])
closest_point = rs.CurveClosestPoint(
self.cross_sections[cross_section_index], point)
crv = rs.CurveCurvature(self.cross_sections[cross_section_index],
closest_point)
crvTangent = crv[1]
crvPerp = rs.VectorUnitize(crv[4])
unit_vector = rs.VectorUnitize(crvTangent)
return [
rs.VectorScale(unit_vector, 0.205),
rs.VectorReverse(rs.VectorCrossProduct(crvTangent, crvPerp))
]
def cross_section_plane_no_curvature(self,
t,
prev_normal=None,
prev_perp=None):
crvPoint = rs.EvaluateCurve(self.curve_object, t)
crvTangent = rs.CurveTangent(self.curve_object, t)
crvPerp = (0, 0, 1)
crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
if prev_normal:
crvNormal = self.reverse_if_needed(crvNormal, prev_normal)
if prev_perp:
crvPerp = self.reverse_if_needed(crvPerp, prev_perp)
return rs.PlaneFromFrame(crvPoint, crvPerp, crvNormal)
def vectorfield():
cloud_id = rs.GetObject("Input pointcloud", 2, True, True)
if cloud_id is None: return
listpoints = rs.PointCloudPoints(cloud_id)
base_point = rs.GetPoint("Vector field base point")
if base_point is None: return
for point in listpoints:
vecbase = rs.VectorCreate(point, base_point)
vecdir = rs.VectorCrossProduct(vecbase, (0, 0, 1))
if vecdir:
vecdir = rs.VectorUnitize(vecdir)
vecdir = rs.VectorScale(vecdir, 2.0)
AddVector(vecdir, point)
def MakeSectionPreview(line, size): arrow = []# 目印を格納するリスト for i in range(len(line)): vec_x = rs.VectorCreate(rs.CurveStartPoint(line[i]), rs.CurveEndPoint(line[i])) vec_y = rs.VectorUnitize(rs.VectorCrossProduct(vec_x, [0,0,1])) pt3 = rs.DivideCurve(line[i], size) seglen = rs.Distance(pt3[0], pt3[1]) tri_s = [rs.AddPoint(pt3[i]) for i in range(3)] tri_e = [rs.AddPoint(pt3[len(pt3) - i]) for i in range(1, 4)] rs.MoveObject(tri_s[1], vec_y * (seglen * sqrt(3))) rs.MoveObject(tri_e[1], vec_y * (seglen * sqrt(3))) arrow.append(rs.AddInterpCurve(rs.coerce3dpointlist(tri_s), 1)) arrow.append(rs.AddInterpCurve(rs.coerce3dpointlist(tri_e), 1)) return arrow
def is_point_on_plane_top(pt, plane, reverse=False):
testVect = plane.XAxis
if plane.XAxis.Z != 0:
testVect = plane.YAxis
pp1 = plane.Origin
pp2 = pp1 + testVect
v1 = pp1 - pt
v2 = pp2 - pt
n = rs.VectorCrossProduct(v1, v2)
flag = n.Z > 0
if reverse:
return not flag
return flag
def orientObjAlongPolyPts(obj, pts, baseVect=(0, 1, 0)):
up = (0, 0, 1)
for i in range(0, len(pts) - 1):
if i < (len(pts) - 2):
p0 = pts[i]
p1 = pts[i + 1]
p2 = pts[i + 2]
v1 = rs.VectorUnitize(p1 - p0)
v2 = rs.VectorUnitize(p2 - p1)
n1 = rs.VectorCrossProduct(v1, up)
n2 = rs.VectorCrossProduct(v2, up)
mid = rs.VectorAdd(n1, n2)
n = rs.VectorUnitize(mid)
else:
p0 = pts[i]
p1 = pts[i + 1]
v1 = rs.VectorUnitize(p1 - p0)
n = rs.VectorCrossProduct(v1, up)
rs.AddLine(p1, p1 + n)
a = rs.VectorAngle((0, 1, 0), n)
rs.OrientObject(obj, [(0, 0, 0), baseVect], [p1, p1 + n], 1)
def surfaceIrradiance_fixed(towerIn, sunIn, intensityIn):
sunUnit = rs.VectorUnitize(sunIn)
for floor in range(len(towerIn)):
numPoints = len(towerIn[floor])
for i in range(numPoints):
p1 = towerIn[floor][i]
p2 = towerIn[floor][(i + 1) % numPoints]
v1 = rs.VectorSubtract(p2, p1)
v2 = [0, 0, 1]
n = rs.VectorCrossProduct(v1, v2)
if rs.VectorLength(n) > rs.UnitAbsoluteTolerance(10**(-3), True):
cosTheta = rs.VectorDotProduct(rs.VectorUnitize(n), sunUnit)
if cosTheta > 0:
factor = intensityIn * cosTheta / 200 #200 is just to shorten the vector to something manageable
v = rs.VectorScale(n, factor)
AddVector(v, p1)
def face_pt(face, u, v, z):
'''
calculate the new center point of a face
'''
pts = [vertices[f] for f in face]
vpface = len(pts)
mid = (1 - u) * (1 - v) * pts[0] + u * (
1 - v) * pts[1] + u * v * pts[2] + (1 - u) * v * pts[-1]
vec_mid = [p - mid for p in pts]
vec_cross = [
rs.VectorCrossProduct(vec_mid[(i + 1) % vpface], vec_mid[i])
for i in range(vpface)
]
for i in range(1, vpface):
vec_cross[0] = vec_cross[i] + vec_cross[0]
return mid + vec_cross[0] * z
def minBoundingBox(crv):
"""Returns the minimal 2d bounding box of a curve or surface.
Parameters:
crv (curve) = planar curve or surface
Returns:
polylineCurve = min polyline based on area
"""
#Get control points
P = rs.CurveEditPoints(crv)
p = []
for i in range(0, len(P)-1):
p.append(P[i])
#get The convex hull
hull = ConvexHull(p)
convexHull = hull.get_polyline()
minArea = None
minBoundary = None
plane = crv.TryGetPlane()[1]
normal = plane.Normal
#For each edge
for i in range(convexHull.SegmentCount):
edge = convexHull.SegmentAt(i)
segVec = edge.PointAt(0) - edge.PointAt(1)
yVec = rs.VectorCrossProduct(normal, segVec)
plane = rg.Plane(rs.coerce3dpoint((0,0,0)), segVec, yVec)
bbPts = rs.BoundingBox(crv, view_or_plane = plane)
newPts = bbPts[:4]
newPts.append(bbPts[0])
pline = rg.PolylineCurve(newPts)
am = rg.AreaMassProperties.Compute(pline)
area = am.Area
if area < minArea or minArea is None:
minArea = area
minBoundary = pline
return minBoundary
def ImportLighthouseSensorsFromJSON(filename):
print "Reading", filename
contents = file(filename).read()
if "{" not in contents:
raise Exception("Malformed JSON")
header = contents[0:contents.find('{')]
print header
try:
layername = os.path.splitext(os.path.basename(filename))[0].lower()
except:
layername = "sensors"
jsonstr = contents[contents.find('{'):]
data = json.loads(jsonstr)
originalLayer = rs.CurrentLayer()
layername = rs.AddLayer(layername)
rs.CurrentLayer(layername)
rs.LayerColor(layername, RandomSaturatedColor())
groupName = rs.AddGroup(layername)
SENSOR_RADIUS_MM = 3.0
SENSOR_NORMAL_LENGTH_MM = 8.0
for point, normal in zip(data['modelPoints'], data['modelNormals']):
position = rs.coerce3dvector([x * 1000.0 for x in point])
normal = rs.VectorUnitize(normal)
normalOrthoA = Orthogonal(normal)
normalOrthoB = rs.VectorCrossProduct(normalOrthoA, normal)
objID = rs.AddCircle3Pt(position + SENSOR_RADIUS_MM * normalOrthoA,
position - SENSOR_RADIUS_MM * normalOrthoA,
position + SENSOR_RADIUS_MM * normalOrthoB)
rs.AddObjectToGroup(objID, groupName)
objID = rs.AddLine(position,
position + SENSOR_NORMAL_LENGTH_MM * normal)
rs.AddObjectToGroup(objID, groupName)
rs.CurrentLayer(originalLayer)
def create_square(self, start_point, end_point, start_vector):
across = rs.VectorUnitize(end_point - start_point)
up = rs.VectorScale(start_vector, 0.5)
over_unit = rs.VectorUnitize(rs.VectorCrossProduct(up, across))
over = rs.VectorScale((over_unit), 0.5)
points_inner = []
points_inner.append(rs.PointAdd(start_point, rs.VectorAdd(up, over)))
points_inner.append(
rs.PointAdd(points_inner[0], rs.VectorReverse(over_unit)))
points_inner.append(
rs.PointAdd(points_inner[1], rs.VectorReverse(start_vector)))
points_inner.append(rs.PointAdd(points_inner[2], over_unit))
points_outer = []
points_outer.append(
rs.PointAdd(start_point, rs.VectorAdd(start_vector, over_unit)))
points_outer.append(
rs.PointAdd(points_outer[0],
rs.VectorScale(rs.VectorReverse(over_unit), 2)))
points_outer.append(
rs.PointAdd(points_outer[1],
rs.VectorScale(rs.VectorReverse(start_vector), 2)))
points_outer.append(
rs.PointAdd(points_outer[2], rs.VectorScale(over_unit, 2)))
return [points_outer, points_inner, across]
#Function to draw a vector_A
def AddVector(base, vec):
rs.AddPoint(base)
tip = rs.PointAdd(base, vec)
line = rs.AddLine(base, tip)
rs.CurveArrows(line, 2)
#Base_point and direction of an original vector
base_point = (20, 10, 5)
vector_A = (10, 10, 10)
AddVector(base_point, vector_A)
#Create vector
vector_B = rs.VectorCreate((25, 16, -2), base_point)
AddVector(base_point, vector_B)
#Vector add
vector_C = rs.VectorAdd(vector_A, vector_B)
AddVector(base_point, vector_C)
#vector dot product
s = rs.VectorDotProduct(vector_A, vector_B)
print s
#Vector cross product
vector_D = rs.VectorCrossProduct(vector_A, vector_B)
AddVector(base_point, vector_D)
length_D = rs.VectorLength(vector_D)
print length_D
def main():
global inner_curves, outer_curves, curve_coords
# save for later
orig_hidden_objects = rs.HiddenObjects()
# we put reference points in the dogbone-ref layer, so create it if it doesn't exist
rs.AddLayer("dogbone-ref")
panel, face = getsubsurface.GetSubSurface("select dogbone face")
diameter = rs.GetReal("enter cutter diameter", number=0.25)
diameter = diameter * 1.1
rs.EnableRedraw(False)
# compute the plane
normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5, 0.5)))
plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal)
rs.ViewCPlane(plane=plane)
rs.ProjectOsnaps(True)
outer_curves = rs.DuplicateSurfaceBorder(face, 1)
inner_curves = rs.DuplicateSurfaceBorder(face, 2)
# make a dict mapping each curve to the coords in that curve
curve_coords = dict()
for curve in outer_curves + inner_curves:
coords = rs.CurvePoints(curve)[:-1]
curve_coords[curve] = coords
# make a dict mapping each curve to the z component of its cross product at each index
curve_cross_zs = dict()
for curve, coords in curve_coords.items():
proj_coords = [rs.SurfaceClosestPoint(face, coord) for coord in coords]
cross_zs = []
for idx in range(len(proj_coords)):
triplet = [
proj_coords[(idx + 1) % len(proj_coords)], proj_coords[idx],
proj_coords[(idx - 1) % len(proj_coords)]
]
v0 = (triplet[1][0] - triplet[0][0], triplet[1][1] - triplet[0][1],
0)
v1 = (triplet[2][0] - triplet[1][0], triplet[2][1] - triplet[1][1],
0)
cross_z = rs.VectorCrossProduct(v0, v1)[2]
cross_zs.append(cross_z)
curve_cross_zs[curve] = cross_zs
points = []
bones = []
temp_points = []
rs.EnableRedraw(True)
while True:
coord = rs.GetPoint("select corner")
if coord is None:
break
try:
curve, idx = get_curve_and_idx_for_coord(coord)
point = rs.AddPoint(coord)
rs.ObjectColor(point, (255, 0, 0))
temp_points.append(point)
bones.append((curve, idx))
except ValueError:
print "invalid curve point"
continue
rs.EnableRedraw(False)
rs.DeleteObjects(temp_points)
# try to automatically identify dogbone points if user selected none
if len(bones) == 0:
for curve, coords in curve_coords.items():
proj_coords = [
rs.SurfaceClosestPoint(face, coord) for coord in coords
]
for idx in range(len(proj_coords)):
triplet = [
proj_coords[(idx + 1) % len(proj_coords)],
proj_coords[idx], proj_coords[(idx - 1) % len(proj_coords)]
]
if curve_cross_zs[curve][idx] > 0:
bones.append((curve, idx))
# make the bones
extrusions = []
for bone in bones:
curve, idx = bone
coords = curve_coords[curve]
point = rs.AddPoint(coords[idx])
rs.ObjectLayer(point, "dogbone-ref")
triplet = [
coords[(idx + 1) % len(coords)],
coords[idx],
coords[(idx - 1) % len(coords)],
]
angle = rs.Angle2(
(triplet[1], triplet[0]),
(triplet[1], triplet[2]),
)
angle = angle[0]
# This is a hacky method to determine the handedness of the curve
# the cross product SHOULD have worked here, but for some reason
# it did not.
v0 = triplet[2][0] - triplet[1][0], triplet[2][1] - triplet[1][1], 0
v1 = triplet[1][0] - triplet[0][0], triplet[1][1] - triplet[0][1], 0
_angle = math.degrees(
math.atan2(v0[1], v0[0]) - math.atan2(v1[1], v1[0]))
while _angle > 180:
_angle -= 360
while _angle < -180:
_angle += 360
if math.copysign(1, angle) != math.copysign(1, _angle):
angle -= 180
point = rs.VectorAdd(
triplet[1],
rs.VectorRotate(
0.5 * diameter *
rs.VectorUnitize(rs.VectorSubtract(triplet[2], triplet[1])),
angle / 2, (0, 0, 1)))
circle = rs.AddCircle((point.X, point.Y, -10), diameter / 2.0)
circle_srf = rs.AddPlanarSrf(circle)
p0 = (point.X, point.Y, -10)
p1 = (point.X, point.Y, 10)
line = rs.AddLine(p0, p1)
extrusion = rs.ExtrudeSurface(circle_srf, line)
extrusions.append(extrusion)
rs.DeleteObjects([circle, circle_srf, line])
rs.BooleanDifference([panel], extrusions, delete_input=True)
rs.DeleteObject(panel)
rs.DeleteObjects(extrusions)
rs.DeleteObjects(points)
rs.DeleteObjects(inner_curves)
rs.DeleteObjects(outer_curves)
rs.DeleteObject(face)
rs.ShowObject(rs.AllObjects())
rs.HideObjects(orig_hidden_objects)
rs.EnableRedraw(True)
vector3 = rs.VectorAdd(vector1, vector2)
if unit == "Yes":
vector3 = rs.VectorUnitize(vector3) * scale
#copy the origin and move it along the new vector
newPt = rs.CopyObject(originPt, vector3)
#visualize the vector with a green line
rs.ObjectColor(rs.AddLine(origin, newPt), (0, 255, 0))
#Subtraction of Two Vectors
elif result == "Vector Subtraction":
vector3 = rs.VectorSubtract(vector1, vector2)
if unit == "Yes":
vector3 = rs.VectorUnitize(vector3) * scale
#copy the origin point and move along new vector
newPt = rs.CopyObject(originPt, vector3)
#visualize the vector with a green line
rs.ObjectColor(rs.AddLine(origin, newPt), (0, 255, 0))
elif result == "Vector Dot Product":
vector3 = rs.VectorDotProduct(vector1, vector2)
#dot product is just a scalar value print it to screen for now
print vector3
elif result == "Vector Cross Product":
vector3 = rs.VectorCrossProduct(vector1, vector2)
if unit == "Yes":
vector3 = rs.VectorUnitize(vector3) * scale
newPt = rs.CopyObject(originPt, vector3)
rs.ObjectColor(rs.AddLine(origin, newPt), (0, 255, 0))
def optimization_rotate(_origin_point, _x_point, _y_point, _unused_srf,
_unused_line, _unused_polyline, _unused_mark_line,
_used_srf1, unused_timber, tolerance):
start_time = time.time()
# 初期変数
origin_point = _origin_point
x_point = _x_point
y_point = _y_point
unused_srf = _unused_srf
unused_line = _unused_line
unused_polyline = _unused_polyline
unused_mark_line = _unused_mark_line
used_srf1 = _used_srf1
angle1 = 0.1
angle2 = -0.03
curve_length = []
count1 = 0
angle2_flag = False
end_joint_count = 0
# 回転平面を定義する
new_plane = rs.PlaneFromPoints(origin_point, x_point, y_point)
rs.ViewCPlane(None, new_plane)
rotate_p = origin_point
vec1 = rs.VectorCreate(x_point, rotate_p)
vec2 = rs.VectorCreate(y_point, rotate_p)
cross = rs.VectorCrossProduct(vec1, vec2)
cross_unit = rs.VectorUnitize(cross)
rotate_vec = rs.VectorScale(cross_unit, 100)
# 描画
# rotate_axis = AddVector(rotate_p, rotate_vec)
# print("-------------------------------------------------------")
# 衝突判定
for i in range(200):
curve = rs.IntersectBreps(unused_srf, used_srf1)
# もし接触しなかった場合
if curve is None:
curve_length = []
if i == 0:
angle2_flag = True
angle2 = -1.0
if i == 1:
angle = (angle1 * -1.1)
rs.RotateObject(unused_srf, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle,
rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle,
rotate_vec)
if i == 199:
print("tan2: Can not optimize")
# input("Can not optimize")
# object削除
if curve:
for k in range(0, len(curve)):
rs.DeleteObject(curve[k])
# 平面をもとのxy平面に戻す
origin_point = (0, 0, 0)
x_point = (100, 0, 0)
y_point = (0, 100, 0)
new_plane = rs.PlaneFromPoints(origin_point, x_point, y_point)
rs.ViewCPlane(None, new_plane)
# run time console
end_time = time.time()
optimization_rotate_run_time = end_time - start_time
# print("---------------------------------------------------")
# print("optimization_rotate Run time: %s" % optimization_rotate_run_time)
return False
# console
# print("There is not curve[%s] angle2: %s" % (i, angle2))
rs.RotateObject(unused_srf, rotate_p, angle2, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle2, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle2, rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle2, rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle2, rotate_vec)
count1 = count1 + 1
# もし20回連続で接触しない場合、回転方向を逆転する
if count1 == 10 and angle2_flag:
angle2 = angle2 * -1.0
angle = 10 * angle2
rs.RotateObject(unused_srf, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle,
rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle,
rotate_vec)
angle2_flag = False
continue
# もし接触した場合
else:
length = 0
for j in range(0, len(curve)):
if rs.IsCurve(curve[j]):
length = length + rs.CurveLength(curve[j])
else:
rs.RotateObject(unused_srf, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle1,
rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle1,
rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle1,
rotate_vec)
continue
# 接点2の接触部の長さを格納する
curve_length.append(length)
# もし衝突交線の値が大きくなる場合、回転の方向を逆転する
if len(curve_length) == 5:
if curve_length[0] < curve_length[1] < curve_length[
2] < curve_length[3] < curve_length[4]:
angle1 = angle1 * -1.0
# print("update angle1")
# print("angle1: %s" % angle1)
angle = 3.0 * angle1
rs.RotateObject(unused_srf, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle,
rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle,
rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle,
rotate_vec)
curve_length = []
# 接合条件を満たした場合
if length < tolerance:
select_curve = curve[0]
reference_point = createMidPointFromCurve(select_curve)
check_domain = unused_timber.judgeSurfaceDomain(
reference_point)
# もし接触部が端部(domainが0か8の時)
if check_domain == 0 or check_domain == 8:
rs.RotateObject(unused_srf, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle1,
rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle1,
rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle1,
rotate_vec)
end_joint_count = end_joint_count + 1
if end_joint_count == 2:
# print("tan2: Can not optimize(joint is ends)")
# run time console
end_time = time.time()
optimization_rotate_run_time = end_time - start_time
# print("---------------------------------------------------")
# print("optimization_rotate Run time: %s" % optimization_rotate_run_time)
return False
continue
else:
# print("tan2 <count: %s | curve_length = %s>" % (i, length))
# 平面をもとのxy平面に戻す
origin_point = (0, 0, 0)
x_point = (100, 0, 0)
y_point = (0, 100, 0)
new_plane = rs.PlaneFromPoints(origin_point, x_point,
y_point)
rs.ViewCPlane(None, new_plane)
# run time console
end_time = time.time()
optimization_rotate_run_time = end_time - start_time
# print("optimization_rotate Run time: %s" % optimization_rotate_run_time)
return curve
# 接合条件を満たさなかった場合
else:
# angleを更新
if length < 45:
if angle1 > 0:
angle1 = 0.05
else:
angle1 = -0.05
elif length < 60:
if angle1 > 0:
angle1 = 0.25
else:
angle1 = -0.25
elif length < 70:
if angle1 > 0:
angle1 = 0.35
else:
angle1 = -0.35
elif length < 100:
if angle1 > 0:
angle1 = 0.65
else:
angle1 = -0.65
elif length < 120:
if angle1 > 0:
angle1 = 1.75
else:
angle1 = -1.75
else:
if angle1 > 0:
angle1 = 2.0
else:
angle1 = -2.0
rs.RotateObject(unused_srf, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_line, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_polyline, rotate_p, angle1, rotate_vec)
rs.RotateObject(unused_mark_line[0], rotate_p, angle1,
rotate_vec)
rs.RotateObject(unused_mark_line[1], rotate_p, angle1,
rotate_vec)
# print("curve length[%s]: %s | angle1: %s" % (i, length, angle1))
# object削除
for k in range(0, len(curve)):
rs.DeleteObject(curve[k])
if i == 199:
# print("tan2: Can not optimize")
if curve:
for k in range(0, len(curve)):
rs.DeleteObject(curve[k])
# 平面をもとのxy平面に戻す
origin_point = (0, 0, 0)
x_point = (100, 0, 0)
y_point = (0, 100, 0)
new_plane = rs.PlaneFromPoints(origin_point, x_point,
y_point)
rs.ViewCPlane(None, new_plane)
# run time console
end_time = time.time()
optimization_rotate_run_time = end_time - start_time
# print("---------------------------------------------------")
# print("optimization_rotate Run time: %s" % optimization_rotate_run_time)
return False
