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