“””
\n##########################################################
\nscript written by Luis Felipe Paris & Ezio Blasetti
\nscript version Nov. 20, 2012
\n#########################################################
\n“””<\/p>\n
import rhinoscriptsyntax as rs
\nimport random<\/p>\n
class machine():<\/p>\n
def __init__(self,PTA,CRVS,DIST):<\/p>\n
####MAX DIST####
\nself.maxDist = DIST
\n####CLOSEST POINT###
\nminDist = 5000000000000000000 #large number
\nfor crv in CRVS:
\nif crv is not None:
\nt = rs.CurveClosestPoint(crv, PTA)
\nclPt = rs.EvaluateCurve(crv,t)
\ndist = rs.Distance(PTA, clPt) #distance to closest point on each curve
\nif dist < minDist: #if distance is smaller than last one
\nminDist = dist #set minDist to this one
\nclPt = clPt #set closest pt to this one
\n####POINT B####
\nvec = rs.VectorCreate(PTA,clPt)#vector to closest point
\nvec = rs.VectorUnitize(vec)
\nzVec = rs.VectorCreate([0,0,1],[0,0,0])#Unit Z Vector \\\\NOT NECESSARY FOR 3D
\ntrans = rs.VectorRotate(vec,90,zVec)
\nPTB = rs.CopyObject(PTA,trans) #end point for line<\/p>\n
####################
\nself.ptsA = [rs.PointCoordinates(PTA)] #list of points a
\nself.idsA = [PTA] #list of ids a<\/p>\n
self.ptsB = [rs.PointCoordinates(PTB)] #list of points b
\nself.idsB = [PTB] #list of ids b<\/p>\n
self.vecs = [vec] #list of direction vectors<\/p>\n
self.trailPts = [PTA] #list of trail points
\nself.trails = []<\/p>\n
self.boundsCount = [] #empty list for number of times is far from start point
\n####################<\/p>\n
def reflection(self,CRV,POS1,POS2,ID,SCALE):<\/p>\n
scaleR = SCALE*2
\nscaleP = 2000000
\n#create intersection for point a
\nt = rs.CurveClosestPoint(CRV,POS1)
\ninx = rs.EvaluateCurve(CRV, t)
\ninxL = rs.AddLine(POS1, inx)#line to intersect
\nmirrorIntersections = rs.CurveCurveIntersection(inxL, CRV)#list of intersection results
\nrs.DeleteObject(inxL) #delete line
\nfor mirrorInt in mirrorIntersections:
\ninxP = mirrorInt[3] #intersection point
\ninxT = mirrorInt[7] #parameter in CRV<\/p>\n
delList = []<\/p>\n
tan = rs.CurveTangent(CRV,inxT)#tangent vector
\ntan = rs.VectorAdd(tan, inxP)#tangent at curve
\ntan = rs.AddPoint(tan)#TANGENT ADD
\ndelList.append(tan)#Delete List Add<\/p>\n
zVec = rs.VectorCreate([0,0,1],[0,0,0])#Unit Z Vector \\\\NOT NECESSARY FOR 3D<\/p>\n
nor = rs.RotateObject(tan,inxP,90,zVec,copy=True)#rotate 90 degrees to get normal
\npt = rs.MirrorObject(ID,inxP,nor,copy=True)#mirror self using normal as plane info
\ndelList.append(nor)#Delete List Add
\ndelList.append(pt)#Delete List Add<\/p>\n
refl = rs.AddLine(inxP, pt)#line to intersect
\nrefl = rs.ScaleObject(refl,inxP,[scaleR,scaleR,scaleR])#scale
\ndelList.append(refl)#Delete List Add<\/p>\n
plane = rs.AddLine(POS1, POS2) #plane at direction of movement
\nmidPt = rs.VectorAdd(POS1, POS2)#midPoint of plane \/\/add and divide
\nmidPt = rs.VectorDivide(midPt, 2)
\nplane = rs.ScaleObject(plane,midPt,[scaleP,scaleP,scaleP])#scale plane to ensure intersection
\ndelList.append(plane)#Delete List Add<\/p>\n
reflIntersections = rs.CurveCurveIntersection(refl,plane)#list of intersection results<\/p>\n
if type(reflIntersections) == type([]):
\nreflInt = rs.AddPoint(reflIntersections[0][3])#resulting reflection
\nelse: reflInt = rs.CurveEndPoint(refl)<\/p>\n
rs.DeleteObjects(delList)
\nreturn reflInt<\/p>\n
def test(self,CRVS,TRAILS,FCT,MAX,INDEX,TRAILINDEX,RECU,INT):<\/p>\n
####PTS 0####
\nptA0 = self.ptsA[-1] #assign point a info (last item on list)
\nidA0 = self.idsA[-1]<\/p>\n
ptB0 = self.ptsB[-1] #assign point b info (last item on list)
\nidB0 = self.idsB[-1]<\/p>\n
####SEPARATION####
\nif RECU > 0:
\nSEPM = self.separationMirror(CRVS,INDEX,RanOfVis)#find closest Point
\nif SEPM is None: SEPM = [0,0,0]
\nSEPS = self.separationSelf(CRVS,INDEX)#find closest Point
\nif SEPS is None: SEPS = [0,0,0]<\/p>\n
####COHESION####
\nif RECU > 0:
\nCOH = self.cohesion(TRAILS,TRAILINDEX,RanOfVis)
\nif COH is None: COH = [0,0,0]
\nif INT < div:
\nCOH = rs.VectorReverse(COH)<\/p>\n
####PTS 1####
\nCRV = self.findClosestCurve(CRVS,INDEX,RECU)#find closest Curve
\nmirrorVec = self.vecToRefl(idA0, CRV)#vector to point of reflection in mirror
\nscale = rs.VectorLength(mirrorVec)<\/p>\n
ptA1 = self.reflection(CRV, ptA0, ptB0, idA0, scale)#reflection point of point a
\nptB1 = self.reflection(CRV, ptB0, ptA0, idB0, scale) #reflection point of point b<\/p>\n
adjust = 1.00 #adjust for scaling (in case of no intersection)<\/p>\n
if rs.IsPoint(ptA1): ptA1=ptA1
\nelse:
\nptA1=rs.AddPoint(ptA1)
\nadjust = adjust-0.25<\/p>\n
if rs.IsPoint(ptB1): ptB1=ptB1
\nelse:
\nptB1=rs.AddPoint(ptB1)
\nadjust = adjust-0.25<\/p>\n
####DISTANCE TESTS####
\ndInc = rs.Distance(ptA0,ptB0) #distance point a to point b
\ndRefl = rs.Distance(ptA1,ptB1)*adjust #distance in reflected points
\nTest1 = rs.Distance(ptB0,ptA1) #test to check for inversion
\nTest2 = rs.Distance(ptA0,ptA1) #test to check for inversion
\ndStart = rs.Distance(self.ptsA[0],ptA0) #distance from start point<\/p>\n
rs.DeleteObject(ptA1) #delete reflected points
\nrs.DeleteObject(ptB1) #delete reflected points<\/p>\n
ratio = dRefl\/dInc #ratio of distortion
\nratio = 0.00000001 + ratio*FCT #scaling
\nif ratio > MAX*FCT: ratio = MAX*FCT<\/p>\n
####TRANSLATION####
\ntrans = rs.VectorCreate(ptB0, ptA0)#translation vector
\nif unitizeCurrent == True: ##
\ntrans = rs.VectorUnitize(trans)<\/p>\n
if scaleCurrent == True: ##
\ntrans = rs.VectorScale(trans,ratio)<\/p>\n
vec = self.vecs[-1] #direction vector from previous translation<\/p>\n
if unitizePrevious == True: ##
\nvec = rs.VectorUnitize(vec)<\/p>\n
trans = rs.VectorAdd(vec,trans)<\/p>\n
if unitizeResult == True: ##
\ntrans = rs.VectorUnitize(trans)<\/p>\n
####DISTORTION STATES####
\n#if dInc == dRefl: print “true reflection”<\/p>\n
if dInc < dRefl:
\n#print “augmented reflection”
\ntrans = rs.VectorSubtract(trans, rs.VectorScale(rs.VectorUnitize(mirrorVec), ratio))<\/p>\n
if dInc > dRefl:
\n#print “reduced reflection”
\ntrans = rs.VectorAdd(trans, rs.VectorScale(rs.VectorUnitize(mirrorVec), ratio))<\/p>\n
if rs.VectorLength(trans) > maxMove:
\ntrans = rs.VectorUnitize(trans)
\ntrans = rs.VectorScale(trans, maxMove)<\/p>\n
if Test1>Test2:
\n#print “inversion”
\ntrans = rs.VectorReverse(trans)<\/p>\n
if dStart >= self.maxDist:
\n#trans = -1*trans
\nself.boundsCount.append(1)<\/p>\n
####SUM VECTORS####
\nif RECU > 0:
\nmag = rs.VectorLength(trans)<\/p>\n
if rs.VectorLength(SEPM) > mag:
\nSEPM = rs.VectorUnitize(SEPM)
\nSEPM = rs.VectorScale(SEPM,mag)
\nif rs.VectorLength(SEPS) > mag:
\nSEPS = rs.VectorUnitize(SEPS)
\nSEPS = rs.VectorScale(SEPS,mag)
\nif rs.VectorLength(COH) > mag:
\nCOH = rs.VectorUnitize(COH)
\nCOH = rs.VectorScale(COH,mag)<\/p>\n
trans = rs.VectorAdd(SEPM, trans)
\ntrans = rs.VectorAdd(SEPS, trans)
\ntrans = rs.VectorAdd(COH, trans)
\ntrans = rs.VectorUnitize(trans)
\ntrans = rs.VectorScale(trans, mag)<\/p>\n
###################
\nself.vecs.append(trans)
\nnewPtA = rs.VectorAdd(ptA0, trans)
\nself.ptsA.append(newPtA)
\ntp = rs.AddPoint(newPtA)
\nself.idsA.append(tp)<\/p>\n
newPtB = rs.VectorAdd(ptB0, trans)
\nself.ptsB.append(newPtB)
\nself.idsB.append(rs.AddPoint(newPtB))<\/p>\n
self.trailPts.append(tp)
\n###################<\/p>\n
def makeTrails(self,INDEX,RECU):
\nif len(self.trailPts)>2:
\nmyTrailID = rs.AddInterpCurve(self.trailPts) #Control Pts Curve Trajectory
\nself.trails.append(myTrailID)
\nreturn myTrailID<\/p>\n
def vecToRefl(self, PT1, CRV):
\nt = rs.CurveClosestPoint(CRV, PT1)
\nclPt = rs.EvaluateCurve(CRV,t)
\nvec = rs.VectorCreate(clPt, PT1)
\nreturn vec<\/p>\n
def findClosestCurve(self, CRVS, INDEX, RECU):
\nmycoord = self.ptsA[-1] #position at last item of ptsA list
\nminDist = 5000000000000000000 #large number
\nfor crv in CRVS:
\nif crv is not None:
\nif RECU > 0 and crv is not CRVS[INDEX]:
\nt = rs.CurveClosestPoint(crv, mycoord)
\nclPt = rs.EvaluateCurve(crv,t)
\ndist = rs.Distance(mycoord, clPt) #distance to closest point on each curve
\nif dist < minDist: #if distance is smaller than last one
\nminDist = dist #set minDist to this one
\nclosestCurve = crv #set closest crv to this one
\nt = rs.CurveClosestPoint(crv, mycoord)
\nclPt = rs.EvaluateCurve(crv,t)
\ndist = rs.Distance(mycoord, clPt) #distance to closest point on each curve
\nif dist < minDist: #if distance is smaller than last one
\nminDist = dist #set minDist to this one
\nclosestCurve = crv #set closest crv to this one
\nreturn closestCurve<\/p>\n
def separationMirror(self,CRVS, INDEX, RANGE):
\nclosestPt = 0
\nmycoord = self.idsA[-1] #position at last item of ptsA list
\nminDist = RANGE
\nfor crv in CRVS:
\nif crv is not None:
\nif crv is not CRVS[INDEX]:
\nt = rs.CurveClosestPoint(crv, mycoord)
\nclPt = rs.EvaluateCurve(crv,t)
\ndist = rs.Distance(mycoord, clPt) #distance to closest point on each curve
\nif dist < minDist: #if distance is smaller than last one
\nminDist = dist #set minDist to this one
\nclosestPt = clPt #set closest point to this one
\nif closestPt != 0:
\nvec = rs.VectorCreate(mycoord, closestPt)
\nvec = rs.VectorScale(vec, sepMFct)
\nreturn vec
\nelse: return None<\/p>\n
def separationSelf(self,CRVS, INDEX):
\nmycoord = self.idsA[-1] #position at last item of ptsA list
\nminDist = 5000000000000000000 #large number
\nfor pt in self.idsA:
\nif pt is not mycoord:
\ndist = rs.Distance(mycoord, pt)#distance to each previous point
\nif dist < minDist: #if distance is smaller than last one
\nminDist = dist #set minDist to this one
\nclosestPt = pt #set closest point to this one
\nvec = rs.VectorCreate(mycoord, closestPt)
\nvec = rs.VectorScale(vec, sepSFct)
\nreturn vec<\/p>\n
def cohesion(self,TRAILS,TRAILINDEX,RANGE):
\nclosestPt = 0
\nmycoord = self.ptsA[-1] #position at last item of ptsA list
\nminDist = RANGE #large number
\nfor crv in TRAILS:
\nif crv is not TRAILS[TRAILINDEX]:
\nt = rs.CurveClosestPoint(crv, mycoord)
\nclPt = rs.EvaluateCurve(crv,t)
\ndist = rs.Distance(mycoord, clPt) #distance to closest point on each curve
\nif dist < minDist: #if distance is smaller than last one
\nminDist = dist #set minDist to this one
\nclosestPt = clPt #set closest point to this one
\nif closestPt != 0:
\nvec = rs.VectorCreate(closestPt, mycoord)
\nvec = rs.VectorScale(vec, cohFct)
\nreturn vec
\nelse: return None<\/p>\n
def delete(self):
\nself.idsA.pop(0)
\nself.trails.pop()
\nrs.DeleteObjects(self.idsA)
\nrs.DeleteObjects(self.idsB)
\nrs.DeleteObjects(self.trails)<\/p>\n
def Main():
\nrs.EnableRedraw(drawOn)<\/p>\n
baseListLen = len(reflcrvs)<\/p>\n
####TRAILS####
\ntrails = []<\/p>\n
####MACHINE CREATION####
\nmyMachines = []
\nfor i in range(len(startPos)):
\nmyMachines.append(machine(startPos[i],reflcrvs, dist))<\/p>\n
####RUN TEST####
\ncount = 0
\ninterval = 0
\nfor i in range(int(recurrence)):
\nj = 0
\nfor m in myMachines:
\n#print j
\nif len(m.boundsCount) > limit: break
\nk = baseListLen+j
\nm.test(reflcrvs,trails,amplitude,max,k,j,i,interval)
\ntrajectory = m.makeTrails(i,int(recurrence))#append resulting trajectory
\nif i == 0:
\nreflcrvs.append(trajectory)#append resulting trajectory
\ntrails.append(trajectory)
\nreflcrvs[k] = trajectory
\ntrails[j] = trajectory
\nj = j + 1
\ninterval = count % divisor
\ncount = count +1<\/p>\n
################
\nfor m in myMachines:
\nm.delete()
\n################<\/p>\n
#################################################################################
\ndrawOn = False
\nstartPos = rs.GetObjects(“Select Machine Locations”, rs.filter.point, preselect=True) #Initial Position
\nreflcrvs = rs.GetObjects(“Select Reflective Curves”, rs.filter.curve) #Mirrors
\n####AMPLITUDE####
\namplitude = 24 #Amplitude Scale
\nmax = 10.0 #Max Amplitude
\n####BOUNDS####
\nlimit = 500 #limit to kill
\ndist = 10000.0 #distance to kill
\n####SCALING FROM REFLECTION####
\nscaleCurrent = True
\nunitizeCurrent = False
\nunitizePrevious = True
\nunitizeResult = True
\n####SEPARATION & COHESION####
\ncohFct = 0.1
\nsepSFct = 0.3
\nsepMFct = 0.7<\/p>\n
####GLOBALS######################################################################
\nrecurrence = 2000
\nmaxMove = 10.0
\nRanOfVis = 100.0
\ndivisor = RanOfVis\/maxMove*10
\ndiv = divisor\/5
\n#################################################################################
\nMain()<\/p>\n
“””
\n##########################################################
\nscript written by Luis Felipe Paris & Ezio Blasetti
\nscript version Nov. 12, 2012
\n#########################################################
\n“””<\/p>\n
import rhinoscriptsyntax as rs
\nimport math
\nimport random<\/p>\n
fx = 1.50 #Global Variable for Scaling<\/p>\n
def vertOffset(paths,spacing,max,fct,fct2,fct3,recu,per):
\nfor path in paths: #loop through paths<\/p>\n
pLen = rs.CurveLength(path) #length of path
\nnPoints = int(pLen\/spacing) #divide by distance<\/p>\n
crvs = [] #empty curves list
\ncrvLns = [] #empty length list
\ncrvs.append(path) #add path to curves list
\ncrvLns.append(rs.CurveLength(path)) #add length to length list<\/p>\n
for j in range(recu): #loop for a given number of curves to produce<\/p>\n
crv = crvs[j] #get curve
\ninitcrv = crvs[0] #original curve
\ncrvLen = crvLns[j] #get curve length
\npts = [] #empty points list
\ncurvRadiiList = curvPercentage(crv,nPoints) #get curve curvatures radii list<\/p>\n
for i in range(nPoints): #loop through points in curve<\/p>\n
domain = rs.CurveDomain(crv) #get curve domain
\nt = domain[0] + i*(domain[1]-domain[0])\/nPoints #scale parameter to evaluate to domain<\/p>\n
##4 PARAMETERS: VEC, NORMAL, RADIUS, PERCENTAGE
\nvec = rs.CurveCurvature(crv,t)[4]#curvature vector
\nvec = rs.VectorScale(vec,1\/fx)
\ntan = rs.CurveTangent(crv, t)
\nnormal = rs.VectorRotate(tan, 90, [0,0,1])#normal vector
\ncurvRad = rs.CurveCurvature(crv, t)[3]#curvature radius
\nindex = curvRadiiList.index(curvRad)+1
\ncurvRad = curvRad\/fx
\ncurvPer = index\/len(curvRadiiList)#curvature percentage<\/p>\n
##### FISHNET #####
\nif curvPer >= per: #slider test<\/p>\n
##SCALING
\nvec = rs.VectorScale(vec, max\/2)
\nl = rs.VectorLength(vec)<\/p>\n
#for Height
\nif l > max:
\nvec = rs.VectorUnitize(vec)
\nvec = rs.VectorScale(vec, max)
\nl = rs.VectorLength(vec)<\/p>\n
#for CurvatureVector
\nif l > fct2:
\nvec = rs.VectorUnitize(vec)
\nvec = rs.VectorScale(vec, fct2)<\/p>\n
##GLOBAL NORMAL FROM ORIGINAL CURVE
\ninitdomain = rs.CurveDomain(initcrv)
\ninitT = initdomain[0] + i*(initdomain[1]-initdomain[0])\/nPoints
\nglobalNormal = rs.VectorRotate(rs.CurveTangent(initcrv, initT), 90, [0,0,1]) #normal at initcrv<\/p>\n
##CURVATURE RADIUS AT PREVIOUS & NEXT T
\nt0Rad = 0
\nt2Rad = 0
\nif i > nPoints-1 and i < 0:
\nt0 = domain[0] + (i-1)*(domain[1]-domain[0])\/nPoints
\nt0Rad = rs.CurveCurvature(crv, t)[3]#curvature radius at t0
\nt2 = domain[0] + (i+1)*(domain[1]-domain[0])\/nPoints
\nt2Rad = rs.CurveCurvature(crv, t)[3]#curvature radius at t2<\/p>\n
if curvRad – t2Rad > curvRad – t0Rad:
\nglobalNormal2 = rs.VectorAdd(globalNormal,rs.VectorReverse([normal[0],normal[1],globalNormal[2]]))
\nglobalNormal2 = rs.VectorUnitize(globalNormal2)
\nif globalNormal2:
\nglobalNormal2 = rs.VectorScale(globalNormal2, fct)
\nglobalNormal = globalNormal2<\/p>\n
globalNormal = rs.VectorScale(globalNormal, fct*max*math.sqrt(j*i\/nPoints)) #global normal scaling
\nglobalNormal = rs.VectorScale(globalNormal, curvPer+0.01)<\/p>\n
temp = rs.EvaluateCurve(crv,t)
\ntemp = rs.VectorAdd(temp,vec)
\ntemp = rs.VectorAdd(globalNormal, temp)<\/p>\n
pts.append([temp[0],temp[1],temp[2]+l])<\/p>\n
##### CURVATURE JITTER #####
\nelse:
\ncurvRad = curvRad*fct3
\nnormal = rs.VectorUnitize(normal)
\nnormal = rs.VectorScale(normal, curvRad)<\/p>\n
if rs.VectorLength(normal) > fct3:
\nnormal = rs.VectorUnitize(normal)
\nnormal = rs.VectorScale(normal, fct3)<\/p>\n
if rs.VectorLength(normal) < -1*fct3:
\nnormal = rs.VectorUnitize(normal)
\nnormal = rs.VectorScale(normal, -1*fct3)<\/p>\n
h = spacing*(1-curvPer)\/max
\nif h < 0: h = 0<\/p>\n
pt = rs.EvaluateCurve(crv, t)
\npt = rs.VectorAdd(pt, normal)<\/p>\n
pts.append([pt[0],pt[1],pt[2]+h])<\/p>\n
result = rs.AddInterpCurve(pts)
\ncrvLns.append(rs.CurveLength(result))
\ncrvs.append(result)<\/p>\n
“””
\n####MESHING####
\nvtxs = []
\nfvtxs = []
\ncolvtxs = []
\nnPoints = 2000<\/p>\n
for i in range(len(crvs)-1):
\nfor j in range(nPoints):
\nt = domain[0] + j*(domain[1]-domain[0])\/nPoints
\ntemp1 = rs.EvaluateCurve(crvs[i],t)
\ntemp2 = rs.EvaluateCurve(crvs[i+1],t)
\nvtxs.append(temp1)
\nvtxs.append(temp2)<\/p>\n
ran = 40
\nstart = 5
\nh1 = ((((i+1)\/recu)+((j+1)\/nPoints))\/2*ran)+start
\nh2 = ((((i+2)\/recu)+((j+1)\/nPoints))\/2*ran)+start
\nc1 = rs.ColorHLSToRGB([h1,127,255])
\nc2 = rs.ColorHLSToRGB([h2,127,255])
\ncolvtxs.append(c1)
\ncolvtxs.append(c2)<\/p>\n
if j>0:
\ne = len(vtxs)
\nfvtxs.append([e-4,e-2,e-1,e-3])<\/p>\n
rs.AddMesh(vtxs,fvtxs,vertex_colors=colvtxs)
\n“””<\/p>\n
def curvPercentage(crv,nPoints):
\nlList = []
\ndomain = rs.CurveDomain(crv)
\nfor i in range(nPoints):
\nt = domain[0] + i*(domain[1]-domain[0])\/nPoints
\nr = rs.CurveCurvature(crv, t)[3] #radius
\nlList.append(r)
\nlList.sort()
\nreturn lList<\/p>\n
def Main():
\npaths = rs.GetObjects(“Select Curves”, rs.filter.curve, preselect=True)<\/p>\n
“””
\n##relation should be length of curve\/10^2 for scaling and of curve\/10^5 for factors##
\ni.e. len:1000mm & 7 Peaks
\nfx=1
\ndivLen = 5
\nyOffset = 12
\nfactor1 = 0.01
\nfactor2 = 0.08(5)
\n“””<\/p>\n
####TUNING SCALE####
\ndivLen = 2\/fx #a point every __ units(i.e. mm)
\nyOffset = 5\/fx #vertical height offset<\/p>\n
####CONTROL####
\nfactor1 = 0.04\/fx #factor for: FISHNET: GlobalNormal (Overhang)
\nfactor2 = 1\/fx #factor for: FISHNET: Curvature Vector (Jitter)
\nfactor3 = 0.05\/fx #factor 2 for: JITTER: Normal (Loops); Usually good when == factor1*5<\/p>\n
####NUMBER####
\nrecurrence = 5 #number of curves<\/p>\n
####SLIDER####
\npercentage = 0.6 #split percentage point between FISHNET(-0.0001) to JITTER(1.0001)<\/p>\n
vertOffset(paths,divLen,yOffset,factor1,factor2,factor3,recurrence,percentage)
\nMain()<\/p>\n","protected":false},"excerpt":{"rendered":"
“”” ########################################################## script written by Luis Felipe Paris & Ezio Blasetti script version Nov. 20, 2012 ######################################################### “”” import rhinoscriptsyntax as rs import random class machine(): def __init__(self,PTA,CRVS,DIST): ####MAX DIST#### self.maxDist = DIST ####CLOSEST POINT### minDist = 5000000000000000000 #large number for crv in CRVS: if crv is not None: t = rs.CurveClosestPoint(crv, PTA) clPt = […]<\/p>\n","protected":false},"author":2,"featured_media":0,"parent":9,"menu_order":0,"comment_status":"closed","ping_status":"open","template":"","meta":{"footnotes":""},"class_list":["post-1474","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.new-territories.com\/blog\/ncertainties\/col12\/wp-json\/wp\/v2\/pages\/1474","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.new-territories.com\/blog\/ncertainties\/col12\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.new-territories.com\/blog\/ncertainties\/col12\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.new-territories.com\/blog\/ncertainties\/col12\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.new-territories.com\/blog\/ncertainties\/col12\/wp-json\/wp\/v2\/comments?post=1474"}],"version-history":[{"count":4,"href":"https:\/\/www.new-territories.com\/blog\/ncertainties\/col12\/wp-json\/wp\/v2\/pages\/1474\/revisions"}],"predecessor-version":[{"id":1627,"href":"https:\/\/www.new-territories.com\/blog\/ncertainties\/col12\/wp-json\/wp\/v2\/pages\/1474\/revisions\/1627"}],"up":[{"embeddable":true,"href":"https:\/\/www.new-territories.com\/blog\/ncertainties\/col12\/wp-json\/wp\/v2\/pages\/9"}],"wp:attachment":[{"href":"https:\/\/www.new-territories.com\/blog\/ncertainties\/col12\/wp-json\/wp\/v2\/media?parent=1474"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}