def fillet_lines(self): self.lines = [] for i in range(0, len(self.line_lists)): fillets = [] new_line = [] for j in range(0, len(self.line_lists[i]) - 1): fillets.append( rs.AddFilletCurve(self.line_lists[i][j], self.line_lists[i][j + 1], 1)) for k in range(0, len(self.line_lists[i])): line = self.line_lists[i][k] if (k < len(self.line_lists[i]) - 1): line_domain = rs.CurveDomain(line) line_intersect = rs.CurveCurveIntersection( line, fillets[k])[0][5] line = rs.TrimCurve(self.line_lists[i][k], (line_domain[0], line_intersect), True) if (k > 0): line_domain = rs.CurveDomain(line) line_intersect = rs.CurveCurveIntersection( line, fillets[k - 1]) line = rs.TrimCurve(line, (line_intersect[0][5], line_domain[1]), True) new_line.append(line) if (k < len(self.line_lists[i]) - 1): new_line.append(fillets[k]) self.lines.append(rs.JoinCurves(new_line))
def createPipe(self, first, mid, last, text): first_fillet = rs.AddFilletCurve(first, mid, 0.25) fillet_points = rs.CurveFilletPoints(first, mid, 0.25) first_circle = rs.AddCircle(fillet_points[2], 0.125) first_cp = rs.CurveClosestPoint(first, fillet_points[0]) first_domain = rs.CurveDomain(first) nfirst = rs.TrimCurve(first, (first_domain[0], first_cp), False) second_cp = rs.CurveClosestPoint(mid, fillet_points[1]) second_domain = rs.CurveDomain(mid) nmid = rs.TrimCurve(mid, (second_cp, second_domain[1]), False) second_fillet = rs.AddFilletCurve(mid, last, 0.25) fillet_points = rs.CurveFilletPoints(mid, last, 0.25) second_circle = rs.AddCircle(fillet_points[2], 0.125) first_cp = rs.CurveClosestPoint(mid, fillet_points[0]) first_domain = rs.CurveDomain(mid) nmid = rs.TrimCurve(nmid, (first_domain[0], first_cp), False) second_cp = rs.CurveClosestPoint(last, fillet_points[1]) second_domain = rs.CurveDomain(last) nlast = rs.TrimCurve(last, (second_cp, second_domain[1]), False) curve = rs.JoinCurves( [nfirst, first_fillet, nmid, second_fillet, nlast]) print curve pipe = rs.AddPipe(curve, 0, 0.09375, 0, 1) points = [ rs.CurveStartPoint(first), rs.CurveEndPoint(first), rs.CurveStartPoint(last), rs.CurveEndPoint(last) ] self.copyAndMover(first, mid, last, points, text)
def fillet_lines(self): self.lines = [] for i in range(0, len(self.line_lists)): fillets = [] new_line = [] for j in range(0, len(self.line_lists[i]) - 1): first_line = self.line_lists[i][j] second_line = self.line_lists[i][j + 1] fillet = rs.AddFilletCurve(first_line, second_line, 0.125) fillet_points = rs.CurveFilletPoints(first_line, second_line, 0.125) first_cp = rs.CurveClosestPoint(first_line, fillet_points[0]) first_domain = rs.CurveDomain(first_line) self.line_lists[i][j] = rs.TrimCurve( first_line, (first_domain[0], first_cp), True) second_cp = rs.CurveClosestPoint(second_line, fillet_points[1]) second_domain = rs.CurveDomain(second_line) self.line_lists[i][j + 1] = rs.TrimCurve( second_line, (second_cp, second_domain[1]), True) fillets.append(fillet) for k in range(0, len(self.line_lists[i])): new_line.append(self.line_lists[i][k]) if (k < len(self.line_lists[i]) - 1): new_line.append(fillets[k]) new_curve = self.get_curve_from_segments(new_line) self.lines.append(new_curve)
def copyAndMover(self, first, mid, last, points, text): plane = rs.PlaneFromPoints(points[0], points[1], points[2]) uv1 = rs.PlaneClosestPoint(plane, points[1], False) uv2 = rs.PlaneClosestPoint(plane, points[2], False) distHor = abs(uv1[0] - uv2[0]) distVert = abs(uv1[1] - uv2[1]) key = 'len{0}{1}'.format(distHor, distVert) key = re.sub(r'\.', '', key) if key in self.partsHash: self.partsHash[key].append(text) else: self.partsHash[key] = [] self.partsHash[key].append(text) ypos = len(self.partsHash.keys()) + len(self.partsHash.keys()) rs.AddText(key, [0, ypos, 0], 0.3) newPoints = [ rs.AddPoint(0, ypos, 0), rs.AddPoint(self.FLAT_LENGTH, ypos, 0), rs.AddPoint(self.FLAT_LENGTH + distHor, ypos + distVert, 0), rs.AddPoint((self.FLAT_LENGTH * 2) + distHor, ypos + distVert, 0) ] first = rs.OrientObject(first, points, newPoints, 1) mid = rs.OrientObject(mid, points, newPoints, 1) last = rs.OrientObject(last, points, newPoints, 1) first_fillet = rs.AddFilletCurve(first, mid, 0.09375) fillet_points = rs.CurveFilletPoints(first, mid, 0.09375) first_circle = rs.AddCircle(fillet_points[2], 0.09375) first_cp = rs.CurveClosestPoint(first, fillet_points[0]) first_domain = rs.CurveDomain(first) first = rs.TrimCurve(first, (first_domain[0], first_cp), True) second_cp = rs.CurveClosestPoint(mid, fillet_points[1]) second_domain = rs.CurveDomain(mid) mid = rs.TrimCurve(mid, (second_cp, second_domain[1]), True) second_fillet = rs.AddFilletCurve(mid, last, 0.09375) fillet_points = rs.CurveFilletPoints(mid, last, 0.09375) second_circle = rs.AddCircle(fillet_points[2], 0.09375) first_cp = rs.CurveClosestPoint(mid, fillet_points[0]) first_domain = rs.CurveDomain(mid) mid = rs.TrimCurve(mid, (first_domain[0], first_cp), True) second_cp = rs.CurveClosestPoint(last, fillet_points[1]) second_domain = rs.CurveDomain(last) last = rs.TrimCurve(last, (second_cp, second_domain[1]), True) curve = rs.JoinCurves( [first, first_fillet, mid, second_fillet, last]) rs.AddCircle([0, ypos - 0.125 - 0.09375, 0], 0.09375) rs.AddCircle([(self.FLAT_LENGTH * 2) + distHor, ypos + distVert + 0.125 + 0.09375, 0], 0.09375)
def splitLine(line): #obtain the curve (line) minimum and maximum (domain) lineDomain = rs.CurveDomain(line) min = lineDomain[0] max = lineDomain[1] OneThird = (max - min) / 3 TwoThird = (max - min) * 2 / 3 StartLine = rs.TrimCurve(line, (min, min + OneThird), False) EndLine = rs.TrimCurve(line, (min + TwoThird, max)) SplitLine = (StartLine, EndLine) #return the array of two lines return SplitLine
def getExtendedCrv(self, crvList, dist=50, layer_height=2.5, vecMul=.66): segmentCount = int(math.floor(dist / layer_height)) - 1 tmpList = [] fullHeight = [] for i in range(len(crvList)): extendedCrv = rs.ExtendCurveLength(crvList[i], 2, 0, dist) fullHeight.append(extendedCrv) domStart, domEnd = rs.CurveDomain(extendedCrv) trimmedCrv = rs.TrimCurve(extendedCrv, (domStart, 0)) tmpList.append(trimmedCrv) tmp = [] ###Smooth Curves### for i in range(len(tmpList)): bottomPt = rs.CurveEndPoint(tmpList[i]) zVec = rs.VectorAdd((0, 0, 0), (0, 0, dist)) topPt = rs.CopyObject(bottomPt, zVec) line = rs.AddLine(bottomPt, topPt) crvPts = rs.DivideCurve(tmpList[i], segmentCount) LinePts = rs.DivideCurve(line, segmentCount) for i in range(segmentCount): tmpVec = rs.VectorCreate(LinePts[segmentCount - i - 1], crvPts[i]) tmpVec = rs.VectorScale(tmpVec, vecMul) rs.MoveObject(crvPts[i], tmpVec) tmp.append(rs.AddInterpCurve(crvPts)) result = [] for crv in tmp: crvLen = rs.CurveLength(crv) if crvLen < dist: tmpExt = dist - crvLen result.append(rs.ExtendCurveLength(crv, 2, 0, tmpExt)) else: result.append(rs.CopyObject(crv)) return result
def trimOffsetCurves(crvGuids): intersectParams = {} for x in range(0, crvGuids.Count): intersectParams[x] = [] for x in range(0, crvGuids.Count - 1): for y in range(x + 1, crvGuids.Count): if crvGuids[x] != crvGuids[y]: #Check Intersect Curves crvA = rs.coercecurve(crvGuids[x]) crvB = rs.coercecurve(crvGuids[y]) intersections = rg.Intersect.Intersection.CurveCurve( crvA, crvB, sc.doc.ModelAbsoluteTolerance, sc.doc.ModelAbsoluteTolerance) if intersections.Count > 0: intersectParams[x].append(intersections[0].ParameterA) intersectParams[y].append(intersections[0].ParameterB) retGuids = [] for x in range(0, crvGuids.Count): if intersectParams[x][0] > intersectParams[x][1]: tA = intersectParams[x][1] tB = intersectParams[x][0] else: tA = intersectParams[x][0] tB = intersectParams[x][1] guid = rs.TrimCurve(crvGuids[x], (tA, tB)) if guid != None: retGuids.append(guid) return retGuids
def draw_hole(grid00, grid01): grids = [grid00, grid01] points = [] lists = [] for i in grids: domain = rs.CurveDomain(i) domains = [domain[0] + b, domain[1] - b0 * b, domain[1] - b] lists.append(domains) for ii in domains: point = rs.EvaluateCurve(i, ii) points.append(point) for i in range(2): grid = rs.AddCurve([points[i * 3], points[5 - i * 3]]) domain0 = rs.CurveDomain(grid) domain1 = domain0[1] - c point = rs.EvaluateCurve(grid, domain1) #rs.AddPoint(point) rs.AddCurve([point, points[i * 3 + 1]]) rs.TrimCurve(grids[i], (lists[i][0], lists[i][1])) rs.TrimCurve(grid, (domain0[0], domain1))
def offsetRow(self, edge, vec, width): """ Offset a row depending on the type of width and direction. need to use self.edges :return: """ # print("edge", rs.CurveLength(edge)) # print("vec", vec) # print("width", width) newRow = rs.OffsetCurve(edge, vec, width) # Magic number # print("newRow", newRow) # print("newRowCurve", rs.CurveLength(newRow)) rs.ScaleObject(newRow, rs.CurveMidPoint(newRow), [20, 20, 0]) # print("ScaleNewRowCurve", rs.CurveLength(newRow)) # Problem Below!! param = [] for e in self.edges: intersect = rs.CurveCurveIntersection(newRow, e) # Follows the Rhino api if intersect is not None: param.append(intersect[0][5]) # print("param", param) if param[0] < param[1]: newRow = rs.TrimCurve(newRow, [param[0], param[1]]) elif param[0] > param[1]: newRow = rs.TrimCurve(newRow, [param[1], param[0]]) else: # only one intersection, it's time to stop newRow = None # newRow = rs.TrimCurve(newRow, [param[0], param[1]]) # print("TrimNewRowCurve", rs.CurveLength(newRow)) return newRow
def Cargas_Vigas(viga, plD, plB, plC, cob, borda1, borda2, conv): # cob = rs.coercecurve(cob) forces = [] #separando entrada viga em seus elementos (polilinhas) #bs = banzo superior, diag = diagonais, bi = banzo inferior bs, diag, bi = viga #extraindo os nós do banzo superior nos = rs.PolylineVertices(bs) # explodindo polilinhas bs = rs.ExplodeCurves(bs) diag = rs.ExplodeCurves(diag) bi = rs.ExplodeCurves(bi) for i in range(len(nos)): P = 0 if 0 < i < (len(nos) - 1): #banzo inferior P = rs.CurveLength(bi[i]) * plB #banzo superior P += (rs.CurveLength(bs[i - 1]) + rs.CurveLength(bs[i])) / 2 * plB #diagonais P += (rs.CurveLength(diag[i * 2]) + rs.CurveLength(diag[(i * 2) + 1])) * plD #cobertura bs1 = bs[i - 1] bs1 = rs.coerceline(bs1) ptAux1 = bs1.PointAt(.5) bs2 = bs[i] bs2 = rs.coerceline(bs2) ptAux2 = bs2.PointAt(.5) param1 = rs.CurveClosestPoint(cob, ptAux1) param2 = rs.CurveClosestPoint(cob, ptAux2) elif i == 0: #banzo inferior P = rs.CurveLength(bi[i]) * plB #banzo superior P += (rs.CurveLength(bs[i]) / 2) * plB #diagonais P += (rs.CurveLength(diag[i * 2]) + rs.CurveLength(diag[(i * 2) + 1])) * plD #cobertura param1 = 0 bs1 = bs[i] bs1 = rs.coerceline(bs1) ptAux = bs1.PointAt(.5) #teste.append(ptAux) param2 = rs.CurveClosestPoint(cob, ptAux) elif i == (len(nos) - 1): #banzo superior e conector P = (rs.CurveLength(bs[i - 1]) + rs.CurveLength(borda1)) / 2 * plB #conector P += rs.CurveLength(borda2) * plB #cobertura bs1 = bs[i - 1] bs1 = rs.coerceline(bs1) ptAux1 = bs1.PointAt(.5) borda1 = rs.coerceline(borda1) ptAux2 = borda1.PointAt(.5) param1 = rs.CurveClosestPoint(cob, ptAux1) param2 = rs.CurveClosestPoint(cob, ptAux2) if not len(diag) % 2 == 0: #banzo inferior P += rs.CurveLength(bi[i]) * plB #diagonal P += (rs.CurveLength(diag[i * 2])) * plD P_viga = P if not param1 == param2: cobAux = rs.TrimCurve(cob, [param1, param2], False) P_cob = rs.CurveLength(cobAux) * plC P += P_cob P *= conv forces.append(P) return forces, P_viga, P_cob
def EixosVigas(BZ, DiagN, d1, od1, d2, od2): #----Diagnoais---- #dividir o banzo superior 1 em 2 x (numero de diagonais de v) ptB1 = rs.DivideCurve(BZ, (2 * DiagN)) #a variável EPcurv armazena o start point do eixo do banzo superior SPCurv = ptB1[0] #exclui o primeiro valor da lista (start point da curva do banzo superior) ptB1 = ptB1[1:] #pAux é o ponto de partida do eixo do banzo inferior pAux = gh.Move(Point3d(SPCurv), -d2 * eY)[0] #Offsets da curva do banzo sup nas distancias d1 e d2 cAux1 = rs.OffsetCurve(BZ, od1, d1, eZ) cAux2 = rs.OffsetCurve(BZ, od2, d2, eZ) #-aplicando mascara binária #ptB1 = lista dos nós do banzo sup ptB1 = gh.Dispatch(ptB1, [False, True, False, False])[0] # iniciando lista dos nós do bazo infeirior apoio = pAux ptB2 = [pAux] #-calculando nós do banzo inferior #contador FOR do primeiro ao penultimo item de ptb1 for i in range(len(ptB1) - 1): #desenha linhas etrne o ponto atual e próximo ponto de ptB1 linAux = Line(ptB1[i], ptB1[i + 1]) #pAux = ponto médio de linAux pAux3 = linAux.PointAt(.5) #calcula ponto em cAux1 mais proximo de pAux #pAux1 =[(coordenadas do pto),(parametro do pto),(distância pto-crv)] pAux1 = gh.CurveClosestPoint(pAux3, rs.coercecurve(cAux1)) #idem - cAux2 #pAux2 = idem pAux2 = gh.CurveClosestPoint(pAux3, rs.coercecurve(cAux2)) #linha entre os pontos equivalentes das curvas cAux1 e cAux2 linAux2 = Line(pAux2[0], pAux1[0]) #cAux3 = cAux1 cortada (trim) no ponto pAux1 cAux3 = rs.TrimCurve(cAux1, (0, pAux1[1]), False) #razão entre o comprimento da curva cAux1 até o ponto pAux1 #e o compriento total de cAux1 prmt = rs.CurveLength(cAux3) / rs.CurveLength(cAux1) #ponto que interpola as alturas VH1 e VH2 pAux = linAux2.PointAt(prmt) #coloca o pto pAux na lista dos nós ptB2.append(pAux) #o ponto final do banzo inferior é colocado no final da lista ptB2 ptB2.append(rs.CurveEndPoint(cAux1)) #-ajuste do ultimo ponto da treliça nosD = gh.Weave([0, 1], ptB2, ptB1) if DiagN % 2 == 0: ptB1.append(rs.CurveEndPoint(BZ)) else: del nosD[-1] #desenha diagonais lDiag = rs.AddPolyline(nosD) #desenha banzo inferior bzInf = rs.AddPolyline(ptB2) #desenha banzo superior bzSup = rs.AddPolyline(ptB1) return lDiag, bzSup, bzInf, nosD, ptB1, ptB2, apoio
def EixosShed(BZ, DiagN, pto): #----Shed---- #dividir o banzo superior 1 em 2 x (numero de diagonais de v3) ptB1 = rs.DivideCurve(BZ, (DiagN)) #exclui o primeiro valor da lista (start point da curva do banzo superior) if DiagN % 2 == 0: mask = [True, False] else: SPCurv = ptB1[0] mask = [False, True] #calcula ponto em cAux1 mais proximo de pAux #pAux =[(coordenadas do pto),(parametro do pto),(distância pto-crv)] pAux = gh.CurveClosestPoint(pto, BZ) #Offsets da curva do banzo sup no ponto pto cAux1 = rs.OffsetCurve(BZ, pto, pAux[2]) #c.append(rs.coercecurve(cAux1)) #-aplicando mascara binária #ptB1 = lista dos nós do banzo sup ptB1 = gh.Dispatch(ptB1, mask)[0] ptB2 = [pto] #-calculando nós do banzo inferior #contador FOR do primeiro ao penultimo item de ptb1 for i in range(len(ptB1) - 1): #desenha linhas etrne o ponto atual e próximo ponto de ptB1 linAux = Line(ptB1[i], ptB1[i + 1]) #pAux = ponto médio de linAux pAux3 = linAux.PointAt(.5) #calcula ponto em cAux1 mais proximo de pAux #pAux1 =[(coordenadas do pto),(parametro do pto),(distância pto-crv)] pAux1 = gh.CurveClosestPoint(pAux3, rs.coercecurve(cAux1)) #idem - cAux2 #pAux2 = idem pAux2 = gh.CurveClosestPoint(pAux3, BZ) #linha entre os pontos equivalentes das curvas cAux1 e cAux2 linAux2 = Line(pAux1[0], pAux2[0]) #a.append(linAux2) #cAux2 = cAux1 cortada (trim) no ponto pAux1 cAux2 = rs.TrimCurve(cAux1, (0, pAux1[1]), False) #razão entre o comprimento da curva cAux1 até o ponto pAux1 #e o compriento total de cAux1 prmt = rs.CurveLength(cAux2) / rs.CurveLength(cAux1) #ponto que interpola as alturas VH1 e VH2 pAux = linAux2.PointAt(prmt * .75) #coloca o pto pAux na lista dos nós ptB2.append(pAux) #-desenhando diagonais e banzo inf #combina lista dos nós, inferiores e superiores #ordenados na sequancia das diagonais nosD = gh.Weave([0, 1], ptB2, ptB1) if DiagN % 2 == 0: del nosD[0] else: ptB1.insert(0, SPCurv) #desenha diagonais lDiag = rs.AddPolyline(nosD) #desenha banzo Superior bzSup = rs.AddPolyline(ptB1) #desenha banzo inferior bzInf = rs.AddPolyline(ptB2) return lDiag, bzSup, bzInf, nosD, ptB1, ptB2,
point = (X, Y, Z) r = r + 0.3 circle = rs.AddCircle(point, r) cir.append(circle) domain = rs.CurveDomain(circle) dom.append(domain) plane = rs.AddPlanarSrf(circle) cplane.append(plane) #rotate the first curve and intersect the curves with circles for i in range(1, 30): curve = rs.AddCurve(points) rcurve = rs.RotateObject(curve, point, i * 10, vector, copy=True) hcurve.append(rcurve) #intersection for h in xrange(0, 7): cur, intpoint = rs.CurveBrepIntersect(rcurve, cplane[h]) split.append(intpoint[0]) #make a domain for each trim and trim the curves domain = rs.CurveDomain(rcurve) domain[1] /= i * 0.08 domain[0] /= i * 2 tcurve = rs.TrimCurve(rcurve, domain) epoint = rs.CurveEndPoint(tcurve) spoint = rs.CurveStartPoint(tcurve) epoints.append(epoint) spoints.append(spoint) ecurve = rs.AddCurve(epoints) scurve = rs.AddCurve(spoints)
if rs.CurveBooleanUnion([polylines[i], polylines[j]]): MN = taxicab_midnormal(pts[i], pts[j], l) ccx = rs.CurveCurveIntersection(polylines[i], MN) if ccx is None: continue if ccx[0][0] == 2: continue para_a = [ccx[0][5], ccx[1][5]] para_b = [ccx[0][7], ccx[1][7]] if para_b[0] > para_b[1]: para_b = [para_b[1], para_b[0]] probable_dash = rs.SplitCurve(polylines[i], para_a) edge = rs.TrimCurve(MN, para_b, False) edgepts = rs.CurvePoints(edge) for crv in probable_dash: crvpts = rs.CurvePoints(crv) if rs.PointCompare(crvpts[0], edgepts[0]): crvpts.reverse() newpl = rs.AddPolyline(edgepts + crvpts) if rs.PointInPlanarClosedCurve(pts[i], newpl): polylines[i] = newpl break ccx = rs.CurveCurveIntersection(polylines[j], MN) if ccx is None: continue para_a = [ccx[0][5], ccx[1][5]]
BzSup1 = rs.coercecurve(Curva) ptX1, prm1, count = gh.CurveXLine(BzSup1, rs.coerceline(Eixo_de_Simetria)) ptAux = gh.Move(ptX1, -eY)[0] #desenha um seguimento no eixo de simetria da treliça lAux = rs.coerceline(Eixo_de_Simetria) cAux = rs.OffsetCurve(BzSup1, ptAux, HV1, eZ) ptX2 = gh.CurveXLine(rs.coercecurve(cAux), lAux)[0] #eixo do conector EixoSimetria = rs.AddLine(ptX1, ptX2) Eixos_do_Conector.append(EixoSimetria) #----Linhas auxiliares dos Banzos Superiores---- #Ponto de corte (trim) do banzo sup. de V1 #ptY1 = [ponto,parametro,dist] ptY1, paramY1, distY1 = gh.CurveClosestPoint(ptX2, BzSup1) #corte (trim) do banzo sup v1 BS1 = rs.TrimCurve(BzSup1, [0, paramY1], False) BS1 = rs.coercecurve(BS1) #-espelhando (mirror) eixo sup de v1 #plano de espelhamento mirplano = rs.PlaneFromNormal(ptX1, eX, eZ) #BS2 = eixo banzo sup de v2 BS2 = gh.Mirror(rs.coercecurve(BS1), mirplano)[0] #cortando a curva incicial no eixo de simetria BS3 = rs.TrimCurve(BzSup1, [prm1, 0], False) BS3 = rs.coercecurve(BS3) #bordas do conector ptY2 = (rs.CurveEndPoint(BS2)) Nos_do_Conector = [ptX1, ptY1, ptX2, ptY2] conect = rs.AddPolyline(Nos_do_Conector + Nos_do_Conector[:1]) Eixos_do_Conector.append(conect) #eixos da viga v1
def trim(self, curve, cutter): resultLines = [] #when arguments are shit, return empty list try: rs.IsCurve(curve) except: ##Debug needs print('IsCurve failed') print(curve) return resultLines try: rs.IsCurve(cutter) except: ##Debug needs print('IsCurve failed') print(cutter) return resultLines if rs.IsCurve(curve) is False or rs.IsCurve(cutter) is False: return resultLines intersectedPoints = rs.CurveCurveIntersection(curve, cutter) if intersectedPoints == None: return resultLines #when cutter is not planar, tmpSurface will be non intersectedPoints = [n[1] for n in intersectedPoints] if len(intersectedPoints) % 2 == 1: #print("In trim(), there is weird") return resultLines #convert point to curve parameter curveParas = [] for i in intersectedPoints: curveParas.append(rs.CurveClosestPoint(curve, i)) for i in range(int(len(curveParas) / 2)): tmp = [] tmp.append(curveParas[i * 2]) tmp.append(curveParas[i * 2 + 1]) try: resultLines.append(rs.TrimCurve(curve, tmp)) except: return [] ##debug needs """ print('trim failed\ncurve,tmp,domain') print(curve) print(tmp) print(rs.IsCurve(curve)) ##debug needs ##why this 'curve' isn't curve? if rs.IsCurve(curve): print(rs.CurveDomain(curve)) """ return resultLines
import rhinoscriptsyntax as rs import random a = 20 x = random.randint(0,a) y = random.randint(0,a) z = random.randint(0,a) p = (x,y,z) p1 = (0,0,0) p2 = (a,a,0) p3 = (0,0,a) for i in range(a): for j in range(a): point = (0,i,j) A = rs.AddPoint(point) rs.HideObject(A) B = rs.AddLine(point,p) rs.TrimCurve(B,(1,3),True)