コード例 #1
0
 def MoveWithVector (treeIn, profPointTreeIn, vectorTreeIn, thicknessIn, angleIn, treeOut):
     
     profMax = GridCornerBig (profPointTreeIn)
     profMin = GridCornerSmall (profPointTreeIn)
     
     max =  GridCornerBig (treeIn)
     
     
     for i in range(treeIn.BranchCount):
         treeBranch = treeIn.Branch(i)
         treePath = treeIn.Path(i)
         
         profBranch = profPointTreeIn.Branch(i)
         vectorBranch = vectorTreeIn.Branch(i)
         thicknessBranch = thicknessIn.Branch(i)
         angleBranch = angleIn.Branch(i)
         
         for j in range(treeBranch.Count):
             elem = treeBranch[j]
             profPoint = profBranch [j]
             vector = vectorBranch [j]
             v = thicknessBranch [j]
             angle = angleBranch [j]
             
             
             if type != 0:
                 elemLapos = rs.AddPoint (elem.X,elem.Y,0)
                 elemLapos = rs.coerce3dvector (elemLapos)
                 
                 #angle = rs.VectorAngle ([1,0,0], elemLapos)
                 betaRad = math.radians (beta)
                 
                 gammaRad = math.radians (angle)
                 
                 if gammaRad > betaRad/2:
                     gammaRad = gammaRad - betaRad/2
                 else:
                     gammaRad = betaRad/2 - gammaRad
                 
                 v = (math.cos (betaRad/2)) / (math.cos (gammaRad)) *v
             
             vec = rs.coerce3dpoint (vector)
             rotVecX = vec.X
             rotVecZ = vec.Y
             rotVecY = vec.Z
             rotVec = rs.AddPoint (rotVecX, rotVecY, rotVecZ)
             rotVec = rs.coerce3dpoint (rotVec)
             ORIGO = rs.AddPoint (0,0,0)
             ORIGO = rs.coerce3dpoint (ORIGO)
             VECTOR = rs.RotateObject(rotVec, ORIGO, angle, [0,0,1])
             
             vector = rs.coerce3dvector (VECTOR)
             vector = vector * v
             
             elem = rs.coerce3dpoint (elem)
             
             MovePoint = rs.MoveObject (elem, vector)
             MovePoint = rs.coerce3dpoint (MovePoint)
             
             treeOut.Add (elem, treePath)
コード例 #2
0
ファイル: MainTemp.py プロジェクト: kellogio90/camrhino
        def FromEdgetoPlane():
            PointPlane = []
            CurveIdList = []
            Brep = []
            edges = rs.GetEdgeCurves()
            if edges:
                for edgeinfo in edges:

                    Brep.append(edgeinfo[1])
                    CurveIdList.append(edgeinfo[0])

            for CurveId in CurveIdList:

                if rs.IsCircle(CurveId):

                    Pt = rs.CircleCenterPoint(CurveId)
                    Normal = rs.CurveNormal(CurveId)
                    LenghtNormal = rs.VectorLength(Normal)
                    LenghNormal = self.m_foronumero.Text
                    LenghNormal = int(LenghNormal)
                    Normal = (LenghNormal * Normal[0], LenghNormal * Normal[1],
                              LenghNormal * Normal[2])
                    PtStill = rs.AddPoint(Pt)

                    Ptmoved = rs.MoveObject(Pt, Normal)
                    Ptmoved = rs.coerce3dpoint(Ptmoved)
                    PtStill = rs.coerce3dpoint(PtStill)

                    PointPlane.append([
                        PtStill[0], PtStill[1], PtStill[2], Normal[0],
                        Normal[1], Normal[2]
                    ])
                    #PointPlane.append([Ptmoved[0],Ptmoved[1],Ptmoved[2],Normal[0],Normal[1],Normal[2]])
            return (PointPlane, Brep)
コード例 #3
0
 def user_function(mesh,i):
  
     for key, a in mesh.vertices_iter(True):
     
        pt = (a['x'], a['y'], a['z'])
        
        if a['type'] == 'fixed' or a['type'] == 'free':
            continue
        if a['type'] == 'guide':
            point = rs.coerce3dpoint(pt)
            rc, t = a['guide_crv'].ClosestPoint(point)
            pt = a['guide_crv'].PointAt(t)
        elif a['type'] == 'surface':
            point = rs.coerce3dpoint(pt)
            pt = a['guide_srf'].ClosestPoint(point)
         
        mesh.vertex[key]['x'] = pt[0]
        mesh.vertex[key]['y'] = pt[1]
        mesh.vertex[key]['z'] = pt[2]    
     
     
     if vis:
         if i%vis==0:
             rs.Prompt(str(i))
             draw_light(mesh,temp = True) 
             Rhino.RhinoApp.Wait()
コード例 #4
0
 def draw(self):
     p1 = rs.coerce3dpoint(self.center + self.sv1)
     p2 = rs.coerce3dpoint(self.center + self.sv2)
     perim = rh.Geometry.Ellipse(rs.coerce3dpoint(self.center), p1, p2)
     perim_id = sc.doc.Objects.AddEllipse(perim)
     perim_nrbs = perim.ToNurbsCurve()
     srf = rh.Geometry.Brep.CreatePlanarBreps(perim_nrbs)[0]
     srf_id = sc.doc.Objects.AddBrep(srf)
コード例 #5
0
 def draw(self):
     p1 = rs.coerce3dpoint(self.center+self.sv1)
     p2 = rs.coerce3dpoint(self.center+self.sv2)
     perim = rh.Geometry.Ellipse(rs.coerce3dpoint(self.center), p1, p2)
     perim_id = sc.doc.Objects.AddEllipse(perim)
     perim_nrbs = perim.ToNurbsCurve()  
     srf = rh.Geometry.Brep.CreatePlanarBreps(perim_nrbs)[0]
     srf_id = sc.doc.Objects.AddBrep(srf)
コード例 #6
0
 def draw(self):
     plane = rs.PlaneFromNormal(rs.coerce3dpoint(self.center), self.nv)
     p1 = rs.coerce3dpoint(self.center + self.sv1 + self.sv2)
     p2 = rs.coerce3dpoint(self.center - self.sv1 - self.sv2)
     p3 = rs.coerce3dpoint(self.center + self.sv1 - self.sv2)
     p4 = rs.coerce3dpoint(self.center - self.sv1 + self.sv2)
     pts = [p1, p4, p2, p3, p1]
     draw_rectangle(pts)
     for pt in pts[0:-1]:
         sc.doc.Objects.AddPoint(pt)
コード例 #7
0
 def draw(self):
     plane = rs.PlaneFromNormal(rs.coerce3dpoint(self.center), self.nv)
     p1 = rs.coerce3dpoint(self.center+self.sv1+self.sv2)
     p2 = rs.coerce3dpoint(self.center-self.sv1-self.sv2)
     p3 = rs.coerce3dpoint(self.center+self.sv1-self.sv2)
     p4 = rs.coerce3dpoint(self.center-self.sv1+self.sv2)
     pts = [p1,p4,p2,p3,p1]
     draw_rectangle(pts)
     for pt in pts[0:-1]:
         sc.doc.Objects.AddPoint(pt)
コード例 #8
0
        def CupolaCollar(treeIn, profilePointsIn, profileVectorsIn, treeOut,
                         ratioOut, profilePointsOut, profileVectorsOut):

            Pmax = GridCornerBig(treeIn)
            Xmax = Pmax.X
            Ymax = Pmax.Y
            Zmax = Pmax.Z

            Pmin = GridCornerSmall(treeIn)
            Xmin = Pmin.X
            Ymin = Pmin.Y
            Zmin = Pmin.Z

            print profilePointsIn

            for i in range(treeIn.BranchCount):
                treeBranch = treeIn.Branch(i)
                treePath = treeIn.Path(i)

                profPointsBranch = profilePointsIn.Branch(i)
                profVectorsBranch = profileVectorsIn.Branch(i)

                for j in range(treeBranch.Count):
                    elem = treeBranch[j]
                    profPoint = profPointsBranch[j]
                    profVector = profVectorsBranch[j]

                    x = elem.X
                    y = elem.Y
                    z = elem.Z

                    Xr = x / Xmax
                    Yr = y / Ymax

                    if Zmax == 0:
                        Zr = 0
                    else:
                        Zr = z / Zmax

                    P1 = rs.AddPoint(Xmin, y, z)
                    P1 = rs.coerce3dpoint(P1)
                    P2 = rs.AddPoint(Xmax, y, z)
                    P2 = rs.coerce3dpoint(P2)
                    path = ghpath(treePath.AppendElement(j))

                    treeOut.Add(P1, path)
                    treeOut.Add(P2, path)
                    ratioOut.Add(Xr, path)
                    profilePointsOut.Add(profPoint, path)
                    profilePointsOut.Add(profPoint, path)
                    profileVectorsOut.Add(profVector, path)
                    profileVectorsOut.Add(profVector, path)
コード例 #9
0
def slopeCalc(p1, p2):

    pt1 = rs.coerce3dpoint(p1)
    pt2 = rs.coerce3dpoint(p2)

    h = pt2.Z - pt1.Z
    pt2.Z = pt1.Z

    dist = pt1.DistanceTo(pt2)
    #print dist
    slope = h * 100 / dist

    return slope
コード例 #10
0
def slopeCalc(p1,p2):
    
    pt1 = rs.coerce3dpoint(p1)
    pt2 = rs.coerce3dpoint(p2)
    
    h = pt2.Z-pt1.Z
    pt2.Z = pt1.Z
 
    dist = pt1.DistanceTo(pt2)
    #print dist
    slope = h*100/dist
    
    return slope
コード例 #11
0
def convertToPolylines(obj):

    # get object properties
    text            = rs.TextObjectText(obj)
    pt              = rs.TextObjectPoint(obj)
    origin          = rs.coerce3dpoint([0,0,0])
    ht              = rs.TextObjectHeight(obj)
    object_layer    = rs.ObjectLayer(obj)
    plane           = rs.TextObjectPlane(obj)
        
    diff = rs.coerce3dpoint([pt.X, pt.Y, pt.Z])

    p1 = rs.WorldXYPlane()
        
    matrix = rs.XformRotation4(p1.XAxis, p1.YAxis, p1.ZAxis, plane.XAxis, plane.YAxis, plane.ZAxis)


    rs.DeleteObject(obj)
        


    # set current layer to put strings in
    prevlayer = rs.CurrentLayer()
    layer = rs.AddLayer('temptextlayer')
    rs.CurrentLayer('temptextlayer')

    # split text at enters
    text = text.split('\r\n')
    opts='GroupOutput=No FontName="timfont" Italic=No Bold=No Height='+ str(ht)
    opts+=" Output=Curves AllowOpenCurves=Yes LowerCaseAsSmallCaps=No AddSpacing=No "
    
    origin.Y += ht * len(text) *1.2
    for item in text:
        rs.Command("_-TextObject " + opts + '"'+item+'"' + " " + str(origin) , False)
        origin.Y -= ht *1.5
        
    #restore current layer
    rs.CurrentLayer(prevlayer)

    
    #select newly created texts
    polylines = rs.ObjectsByLayer('temptextlayer')
    
    # transform to old position
    rs.TransformObjects(polylines, matrix, copy=False)
    rs.MoveObjects(polylines, diff)
    
    rs.ObjectLayer(polylines, object_layer)
    
    return polylines
コード例 #12
0
def convertTextToPolylines2(obj):

    # get object properties
    text = rs.TextObjectText(obj)
    pt = rs.TextObjectPoint(obj)
    origin = rs.coerce3dpoint([0, 0, 0])
    ht = rs.TextObjectHeight(obj)
    object_layer = rs.ObjectLayer(obj)
    plane = rs.TextObjectPlane(obj)

    diff = rs.coerce3dpoint([pt.X, pt.Y, pt.Z])

    p1 = rs.WorldXYPlane()
    #restore view cplane
    rs.ViewCPlane(None, p1)

    matrix = rs.XformRotation4(p1.XAxis, p1.YAxis, p1.ZAxis, plane.XAxis,
                               plane.YAxis, plane.ZAxis)

    rs.DeleteObject(obj)

    # split text at enters
    text = text.split('\r\n')
    opts = 'GroupOutput=No FontName="' + EXPORT_FONT + '" Italic=No Bold=No Height=' + str(
        ht)
    opts += " Output=Curves AllowOpenCurves=Yes LowerCaseAsSmallCaps=No AddSpacing=No "

    n_lines = len(text)

    origin.Y += 1.6 * ht * (len(text) - 1)

    polylines = []
    for item in text:
        rs.Command(
            "_-TextObject " + opts + '"' + item + '"' + " " + str(origin),
            False)
        polylines += rs.LastCreatedObjects()
        origin.Y -= ht * 1.6

    rs.ObjectLayer(polylines, object_layer)

    polylines = rs.ScaleObjects(polylines, (0, 0, 0), (0.7, 1, 1), True)

    # transform to old position
    rs.TransformObjects(polylines, matrix, copy=False)
    rs.MoveObjects(polylines, diff)

    return polylines
コード例 #13
0
def Get_PointOnMeshEdge(msg0, msg1):
    #gets Mesh edge
    go = Rhino.Input.Custom.GetObject()
    go.SetCommandPrompt(msg0)
    go.GeometryFilter = Rhino.DocObjects.ObjectType.MeshEdge
    go.SubObjectSelect = True
    go.GroupSelect = False
    go.AcceptNothing(True)
    if go.Get() != Rhino.Input.GetResult.Object: return
    objref = go.Object(0)
    #get edge index
    index = objref.GeometryComponentIndex.Index
    #get mesh parent
    mesh = objref.Mesh()
    #get line representing mesh edge
    edge_line = mesh.TopologyEdges.EdgeLine(index)
    edge_point = edge_line[0]
    print(type(edge_point.X))
    #start a get point constrained to edge line
    gp = Rhino.Input.Custom.GetPoint()
    gp.SetCommandPrompt(msg1)
    gp.Constrain(edge_line)
    get_rc = gp.Get()
    placed_point = rs.coerce3dpoint(sc.doc.Objects.AddPoint(gp.Point()))
    sc.doc.Views.Redraw()
    #The distance brom edgeline[0] to pickedpoint is calcuated here
    distance = math.sqrt((placed_point.X - edge_point.X)**2 +
                         (placed_point.Y - edge_point.Y)**2 +
                         (placed_point.Z - edge_point.Z)**2)
    return distance
コード例 #14
0
def Build_Key(Point, colors, tol):
    """
    Build key for tolerance shading.
    Create color coded text objects and planes.
    """
    low2 = "-" + str(tol[2]) + '"' + " and lower"
    low1 = "-" + str(tol[2]) + '"' + " to -" + str(tol[1]) + '"'
    low0 = "-" + str(tol[1]) + " to -" + str(tol[0]) + '"'
    good = "-" + str(tol[0]) + " to +" + str(tol[0]) + '"'
    high0 = "+" + str(tol[0]) + " to +" + str(tol[1]) + '"'
    high1 = "+" + str(tol[1]) + " to +" + str(tol[2]) + '"'
    high2 = "+" + str(tol[2]) + " and higher"

    stringList = [high2, high1, high0, good, low0, low1, low2]
    objs = []
    for i in range(len(stringList)):
        pt = rs.coerce3dpoint([0, 0, 1.5 * i + 3])
        plane = rs.PlaneFromNormal(pt + Point, [0, -1, 0], [1, 0, 0])
        txt = rs.AddText(stringList[i], plane)
        srf = rs.AddPlaneSurface(plane, 1, 1)
        rs.MoveObject(srf, [-2, 0, 0])
        stringColor = "Tol_" + colors[i].ToString().split("[")[1].rstrip("]")

        mt.OrganizeLayer(stringColor,
                         Objects=[srf, txt],
                         Render=colors[i],
                         Color=colors[i])
コード例 #15
0
def getSolarGeom(boundary,ht,lat,shourlst,ehourlst,day,north,long,timeZ,s_mth,e_mth):
    CH = ConvexHull2d()
    boundary_pts = rs.CurvePoints(boundary) # you'll need this later
    boundary_pts.pop(-1)
    bchullpts = CH.convex_hull(boundary_pts)
    centerPt = rs.CurveAreaCentroid(rs.AddCurve(bchullpts + [bchullpts[0]],1))[0]
    #centerPt = rs.CurveAreaCentroid(boundary)[0]
    boundary_plane = rs.PlaneFitFromPoints(boundary_pts)
    top_plane = get_plane(boundary,ht)

    # project curve to user_defined height
    sun_pts = get_sunpt(lat,centerPt,s_mth,day,shourlst,north_=north,lon=long,tZ=timeZ,scale_=100)
    sun_pts.extend(get_sunpt(lat,centerPt,e_mth,day,ehourlst,north_=north,lon=long,tZ=timeZ,scale_=100))

    top_lst = project_curve(sun_pts,centerPt,top_plane,boundary)
    top_curves = map(lambda x: rs.coercecurve(x),top_lst) # temp for viz
    top_lst = map(lambda x: rs.CurvePoints(x),top_lst)
    top_pts = map(lambda x: rs.coerce3dpoint(x),\
        reduce(lambda i,j:i+j,top_lst))

    # convex hull methods
    chull_pts = CH.convex_hull(top_pts)
    chull_crv = rs.AddCurve(chull_pts + [chull_pts[0]],1)
    #chull_centerPt = rs.CurveAreaCentroid(chull_crv)[0]
    # adjust curve directions
    #if not rs.CurveDirectionsMatch(boundary,chull_crv):
    #   rs.ReverseCurve(boundary)

    #b = rs.CurvePoints(boundary) + rs.CurvePoints(chull_crv)
    #c = rs.CurvePoints(chull_crv)
    return (boundary,chull_crv),top_curves
コード例 #16
0
    def CalculateColor(i):
        Vertex = MeshObj.Vertices[i]
        Point = rs.coerce3dpoint(Vertex)

        if bb.IsPointInside(Point, tol, True) == False:
            Color = White

        else:
            CP = Brep.ClosestPoint(Point)
            Distance = Point.DistanceTo(CP)
            Color = None

            if Distance < Range[0]:
                Color = Colors[3]  # Green #

            elif Distance < Range[1]:
                if Brep.IsPointInside(Point, tol, True) == True:
                    Color = Colors[4]  #Too Low
                else:
                    Color = Colors[2]  #Too High

            elif Distance < Range[2]:
                if Brep.IsPointInside(Point, tol, True) == True:
                    Color = Colors[5]  #Too Low
                else:
                    Color = Colors[1]  #Too High

            # Outside Range #
            else:
                if Brep.IsPointInside(Point, tol, True) == True:
                    Color = Colors[6]  #Too Low
                else:
                    Color = Colors[0]  #Too High

        ColorList[i] = Color
コード例 #17
0
ファイル: make3d.py プロジェクト: timcastelijn/rhinoscript
def filterObjects(objs):
    new_list = []
    for obj in objs:
        if rs.LayerVisible( rs.ObjectLayer(obj) ):
            # only export visible layers
            if rs.IsCurve(obj):
                new_list.append(obj)

            elif rs.IsPoint(obj):
                # convert to circle
                layer = rs.ObjectLayer(obj)
                point=rs.coerce3dpoint(obj)

                circle = rs.AddCircle(rs.WorldXYPlane(),3)

                rs.ObjectLayer(circle, layer)
                rs.MoveObject(circle, [point.X, point.Y, point.Z])
                new_list.append(circle)
                rs.DeleteObject(obj)
                # rs.DeleteObject(point)

            else:
                # remove from obj list
                rs.DeleteObject(obj)
        else:
            # remove from obj list
            rs.DeleteObject(obj)

    return new_list
コード例 #18
0
def Flows(strSrf,step,iterations):
    
    global p3dDropsPos
    global p3dDropProj
    print "Longitud de la matriz de puntos proyectados: " + str(len(p3dDropProj))
    lines = []
    
    for i in range(0,len(p3dDropProj)):
        for j in range(iterations):
            p3dDummy0 = rs.coerce3dpoint(p3dDropProj[i])
            puvClosest0 = rs.SurfaceClosestPoint(strSrf,p3dDropProj[i])
            v3dNormal = rs.SurfaceNormal(strSrf,puvClosest0)
            v3dMovement = rs.VectorScale(rs.VectorUnitize((v3dNormal[0],v3dNormal[1],0)),step)
            p3dDropProj[i] = rs.PointAdd(p3dDummy0,v3dMovement)
            
            puvClosest1 = rs.SurfaceClosestPoint(strSrf,p3dDropProj[i])
            #print puvClosest1
            p3dDummy1 = rs.EvaluateSurface(strSrf,puvClosest1[0],puvClosest1[1])
            p3dDropProj[i] = p3dDummy1
            #print str(rs.coerce3dpoint(p3dDummy0)) + '|| ' + str(rs.coerce3dpoint(p3dDummy1))
            
            dblLenCheck = rs.Distance(p3dDummy0,p3dDummy1)
            strTrail = rs.AddLine(p3dDummy0,p3dDummy1)
            if dblLenCheck>0.01 and rs.IsCurve(strTrail):
                lines.append(strTrail)
            else:
                break
コード例 #19
0
ファイル: Raindrop.py プロジェクト: Pythones/Ejercicios
 def falls(self,strSrf):
     p3dProjectedPt = rs.ProjectPointToSurface(self.p3dLocation,strSrf,(0,0,-1))
     #print p3dProjectedPt
     #if p3dProjectedPt != None:
     self.p3dLocation = rs.coerce3dpoint(p3dProjectedPt[0])
     #print self.p3dLocation
     rs.AddPoint(self.p3dLocation)
コード例 #20
0
    def Get_SelectPointOnMeshEdge(self, message_0, message_1):
        """Performs 90Lap joint boolean operation to beam object:
        Parameters
        ----------
        message_0: First message to user
        message_1: Second message to user

        Return:
        ------
        Point3D 
        """
        go = Rhino.Input.Custom.GetObject()
        go.SetCommandPrompt(message_0)
        go.GeometryFilter = Rhino.DocObjects.ObjectType.MeshEdge
        go.SubObjectSelect = True
        go.GroupSelect = False
        go.AcceptNothing(True)
        if go.Get() != Rhino.Input.GetResult.Object: return
        objref = go.Object(0)
        index = objref.GeometryComponentIndex.Index
        mesh = objref.Mesh()
        edge_line = mesh.TopologyEdges.EdgeLine(index)
        gp = Rhino.Input.Custom.GetPoint()
        gp.SetCommandPrompt(message_1)
        gp.Constrain(edge_line)
        get_rc = gp.Get()
        placed_point = rs.coerce3dpoint(sc.doc.Objects.AddPoint(gp.Point()))
        sc.doc.Views.Redraw()

        return placed_point
コード例 #21
0
ファイル: Ladybug_SolarFan_alt.py プロジェクト: jtyow/ladybug
def getSolarGeom(boundary,ht,lat,shourlst,ehourlst,day,north,long,timeZ,s_mth,e_mth):
    CH = ConvexHull2d()
    boundary_pts = rs.CurvePoints(boundary) # you'll need this later
    boundary_pts.pop(-1)
    bchullpts = CH.convex_hull(boundary_pts)
    centerPt = rs.CurveAreaCentroid(rs.AddCurve(bchullpts + [bchullpts[0]],1))[0]
    #centerPt = rs.CurveAreaCentroid(boundary)[0]
    boundary_plane = rs.PlaneFitFromPoints(boundary_pts)
    top_plane = get_plane(boundary,ht)

    # project curve to user_defined height
    sun_pts = get_sunpt(lat,centerPt,s_mth,day,shourlst,north_=north,lon=long,tZ=timeZ,scale_=100)
    sun_pts.extend(get_sunpt(lat,centerPt,e_mth,day,ehourlst,north_=north,lon=long,tZ=timeZ,scale_=100))

    top_lst = project_curve(sun_pts,centerPt,top_plane,boundary)
    top_curves = map(lambda x: rs.coercecurve(x),top_lst) # temp for viz
    top_lst = map(lambda x: rs.CurvePoints(x),top_lst)
    top_pts = map(lambda x: rs.coerce3dpoint(x),\
        reduce(lambda i,j:i+j,top_lst))

    # convex hull methods
    chull_pts = CH.convex_hull(top_pts)
    chull_crv = rs.AddCurve(chull_pts + [chull_pts[0]],1)
    #chull_centerPt = rs.CurveAreaCentroid(chull_crv)[0]
    # adjust curve directions
    #if not rs.CurveDirectionsMatch(boundary,chull_crv):
    #   rs.ReverseCurve(boundary)

    #b = rs.CurvePoints(boundary) + rs.CurvePoints(chull_crv)
    #c = rs.CurvePoints(chull_crv)
    return (boundary,chull_crv),top_curves
コード例 #22
0
ファイル: vectors.py プロジェクト: robostrike/RhinoVectors
def ptCheck(a):
    #determines if the submitted point is a point object in space or array value
    #if object is 
    
    #designation implemented to determine if it is not a point object
    designation = 0
    
    try:
        if rs.ObjectType(a) == 1: #collect point object value
            b = rs.coerce3dpoint(a)
        elif rs.ObjectType(a)!= 1: #item is not a point
            designation = 1
    except:
        #item already an array object for use
        b = a
    
    #exporting value
    if designation == 0:
        return b
    #not a point object
    else:
        rs.UnselectAllObjects()
        print "Collecting point value but is another object type"
        rs.SelectObject(a)
        exit()
コード例 #23
0
def checkInputs():
    #Set a default view resolution.
    if _viewResolution_ == None: viewRes = 1
    else: viewRes = _viewResolution_
    
    #Set a default parallel.
    if parallel_ == None: parallel = False
    else: parallel = parallel_
    
    #Check to to see if the connected _testPts are points or planes.
    checkData = True
    viewMethod = 0
    viewPoints = []
    viewPtNormals = []
    for point in _testPtsOrPlanes:
        try:
            #The user has connected planes.
            viewPoints.append(point.Origin)
            viewPtNormals.append(point.Normal)
            viewMethod = 1
        except:
            #The user has connected points.
            try:
                viewPoints.append(rc.Geometry.Point3d(point))
                if viewMethod ==  1: checkData = False
            except:
                viewPoints.append(rc.Geometry.Point3d(rs.coerce3dpoint(point)))
    
    if checkData == False:
        warning = "_testPtsOrPlanes can be either points or planes but not both."
        print warning
        ghenv.Component.AddRuntimeMessage(w, warning)
    
    return checkData, viewRes, viewMethod, viewPoints, viewPtNormals, parallel
コード例 #24
0
def RemoveDuplicatePts(points):
    # Create a dictionary to keep track of the Id
    pointDict = {}
    ptList = []
    for pt in points:
        pt3d = rs.coerce3dpoint(pt)
        pointDict[pt3d] = pt
        ptList.append(pt3d)
    
    #sortList
    ptList.sort()
    ptLast = ptList[-1]
    
    tol = sc.doc.ModelAbsoluteTolerance
    
    for i in range(len(ptList)-2,-1,-1):
        if (abs(ptList[i][0]-ptLast[0]) < tol) and (abs(ptList[i][1]-ptLast[1])) < tol and (abs(ptList[i][2]-ptLast[2]) < tol):
            del ptList[i]
        else:
            ptLast = ptList[i]
    
    #find the the ids with the new list
    outputList = []
    for pt in ptList:
        ptId = pointDict[pt]
        outputList.append(ptId)
    
    return outputList
コード例 #25
0
def MakePlan(elevation, viewDepthZ, geos):
    objs = rs.CopyObjects(geos)
    rs.HideObjects(geos)

    ############################################################################
    print "Cutting Plan"
    allCrvs = []

    #Make plane
    plane = Rhino.Geometry.Plane(rs.coerce3dpoint((0, 0, elevation)),
                                 rs.coerce3dvector((0, 0, 1)))
    planeNeg = Rhino.Geometry.Plane(rs.coerce3dpoint((0, 0, viewDepthZ)),
                                    rs.coerce3dvector((0, 0, 1)))

    ############################################################################
    #Partition the geometry

    partitionedObjs = PartitionGeometry(objs, elevation, viewDepthZ)

    ############################################################################
    #Intersection Curves

    #interCrvs = IntersectGeos(partitionedObjs[1], plane)

    ############################################################################
    #Split Geometry
    #Get the bottom half of intersecting objs
    belowObjs = SplitGeometry(partitionedObjs[1], plane)
    print "A"

    #Get the top half of that previous geometry
    visibleObjs = SplitGeometry(partitionedObjs[0] + belowObjs, planeNeg, -1)

    rs.SelectObjects(visibleObjs)
    objs2del = rs.InvertSelectedObjects()
    rs.DeleteObjects(objs2del)
    print "A"
    ############################################################################
    #Make 2D
    allCrvs += ProjectPlan(visibleObjs, plane)

    rs.DeleteObjects(visibleObjs)

    print "Plan Cut"
    rs.ShowObjects(geos)
    rs.HideObjects(allCrvs)
    return allCrvs
コード例 #26
0
        def PyramidCollar(treeIn, treeOut, ratioOut):

            Pmax = GridCornerBig(treeIn)
            Xmax = Pmax.X
            Ymax = Pmax.Y
            Zmax = Pmax.Z

            Pmin = GridCornerSmall(treeIn)
            Xmin = Pmin.X
            Ymin = Pmin.Y
            Zmin = Pmin.Z

            for i in range(treeIn.BranchCount):
                treeBranch = treeIn.Branch(i)
                treePath = treeIn.Path(i)

                for j in range(treeBranch.Count):
                    elem = treeBranch[j]

                    x = elem.X
                    y = elem.Y
                    z = elem.Z

                    Xr = x / Xmax
                    Yr = y / Ymax

                    if Zmax == 0:
                        Zr = 0
                    else:
                        Zr = z / Zmax

                    P1 = rs.AddPoint(Xmin, Ymin, z)
                    P1 = rs.coerce3dpoint(P1)
                    P2 = rs.AddPoint(Xmin, Ymax, z)
                    P2 = rs.coerce3dpoint(P2)
                    P3 = rs.AddPoint(Xmax, Ymin, z)
                    P3 = rs.coerce3dpoint(P3)
                    P4 = rs.AddPoint(Xmax, Ymax, z)
                    P4 = rs.coerce3dpoint(P4)
                    path = ghpath(treePath.AppendElement(j))

                    treeOut.Add(P1, path)
                    treeOut.Add(P2, path)
                    treeOut.Add(P3, path)
                    treeOut.Add(P4, path)
                    ratioOut.Add(Xr, path)
                    ratioOut.Add(Yr, path)
コード例 #27
0
def align_dims():
    if not sc.doc.Views.ActiveView.ActiveViewport.CameraZ == Rhino.Geometry.Plane.WorldXY.ZAxis:
        print "this works only in top view (world XY)"
        return
    """
    align vertical dimensions horizontally or horizontal dimensions vertically
    version 1.0
    www.studiogijs.nl
    """

    dims = rs.GetObjects("select dims to align", preselect=True, filter=512)
    if not dims:
        return
    p_ref = rs.GetPoint("set basepoint for the dimensions", in_plane=True)
    if not p_ref:
        return
    p_ref = rs.coerce3dpoint(p_ref)

    dims = [rs.coercerhinoobject(dim) for dim in dims]
    for dim in dims:

        vertical = False
        horizontal = False
        rc, e1, e2, a1, a2, dp, tp = dim.Geometry.Get3dPoints()
        if not rc:
            return
        #check arrow endpoints to see if dim is vertical or horizontal
        if a1.Y == a2.Y: horizontal = True
        if a1.X == a2.X: vertical = True

        if not (horizontal or vertical): continue  #next dimension

        #make sure all points are set relative to e1
        #for SetLocations method we need positions of dimension
        #extension lines and text position
        tp -= e1
        p_r = p_ref - e1
        e2 -= e1
        if horizontal:
            #make 2dpoints for setting the new location
            #sometimes dimension plane is inverted
            #depending on where the endpoints wer picked
            px = dim.Geometry.Plane.XAxis.X  #plane x-axis is (1,0,0) or (-1,0,0)
            py = dim.Geometry.Plane.YAxis.Y  #plane y-axis is (0,1,0) or (0,-1,0)
            dp_new = Rhino.Geometry.Point2d(tp.X * px, p_r.Y * py)
            e1_new = Rhino.Geometry.Point2d(0, 0)
            e2_new = Rhino.Geometry.Point2d(e2.X * px, e2.Y * py)
        elif vertical:
            #make 2dpoints for setting the new location
            #notice that vertical dimensions have their plane rotated 90 degrees
            #sometimes dimension plane is inverted
            px = dim.Geometry.Plane.XAxis.Y  #plane x-axis is (0,-1,0) or (0,1,0)
            py = dim.Geometry.Plane.YAxis.X  #plane y-axis is (1,0,0) or (-1,0,0)
            dp_new = Rhino.Geometry.Point2d(tp.Y * px, p_r.X * py)
            e1_new = Rhino.Geometry.Point2d(0, 0)
            e2_new = Rhino.Geometry.Point2d(e2.Y * px, e2.X * py)
        #perform the move
        dim.Geometry.SetLocations(e1_new, e2_new, dp_new)
        dim.CommitChanges()
コード例 #28
0
ファイル: Point.py プロジェクト: sd-work/Sphere-Packing
    def system_guid_obj_to_coordinate(self):
        """System.GuidObjectをRhino.Objectに変換。クラス変数に座標値を保持させる"""

        p = rs.coerce3dpoint(self.point)
        self.x = p[0]
        self.y = p[1]
        self.z = p[2]
        self.coordinate = [p[0], p[1], p[2]]
コード例 #29
0
def estendeFG(linha,corda,ponto):
    linnha = rs.coerceline(linha)
    ponto = rs.coerce3dpoint(ponto)
    if not gh.CurveXCurve(linha,corda)[0]:
        pt =gh.EndPoints(linha)[0]
        construc_aux.append(Line(pt,ponto))
        return True
    else:
        return False
コード例 #30
0
 def set_control_vertices(self, line):
     if tryRhino:
         pt = [float(el) for el in line]
         #pt = rs.AddPoint(pt[0],pt[1],pt[2])
         pt = rs.coerce3dpoint(pt)
         self.control_vertices.append(pt)
     else:
         self.control_vertices.append([float(el) for el in line])
     self.weights = [1. for el in self.control_vertices]
     return
コード例 #31
0
def myPos(I, J, LISTOFCELLS):
    xPos = J * cellsize
    yPos = I * -cellsize
    zPos = LISTOFCELLS[I][J]
    if zPos == -9999:
        zPos = 0
    if geoL == True:
        xPos = xPos + xllcorner
        yPos = yPos + yllcorner + (cellsize * nrows)
    return rs.coerce3dpoint([xPos, yPos, zPos])
コード例 #32
0
    def GetPointDynamicDrawFunc(sender, args):
        point_b = args.CurrentPoint
        point_C = Rhino.Geometry.Point3d((point_a.X + point_b.X) / 2,
                                         (point_a.Y + point_b.Y) / 2,
                                         (point_a.Z + point_b.Z) / 2)
        #Rhino.Geometry.Transform.Translation(
        vec = rs.VectorCreate(point_b, point_a)
        rs.VectorUnitize(vec)
        vec2 = rs.VectorScale(vec, 500)
        vec3 = rs.coerce3dpoint(rs.VectorAdd(point_b, vec2))
        rs.VectorReverse(vec2)
        vec4 = rs.coerce3dpoint(rs.VectorSubtract(point_b, vec2))

        args.Display.DrawLine(point_a, vec3, line_color_1, 1)
        args.Display.DrawLine(point_a, vec4, line_color_1, 1)
        args.Display.DrawPoint(point_a, Rhino.Display.PointStyle.ControlPoint,
                               3, line_color_1)
        args.Display.DrawPoint(point_b, Rhino.Display.PointStyle.ControlPoint,
                               3, line_color_2)
コード例 #33
0
def MakePlanPreview(num):
	points = [(0, 0, 0 + i) for i in num]
	vec_p = [rs.VectorCreate(i, (0,0,0)) for i in points]
	guid = []
	origin = []
	for i in vec_p:
		guid.append(rs.CopyObject(point_p, i))
	for i in guid:
		origin.append(rs.coerce3dpoint(i))# ガイドから3dpointに変換
	return origin
コード例 #34
0
 def check_pt_inputs(self):
     try:
         self._pt_lst = map(lambda p: rs.coerce3dpoint(p), _pt_lst)
         check_data = True
     except:
         warning = 'Could not coerce points. Check your point geometry inputs!'
         print warning
         ghenv.Component.AddRuntimeMessage(
             gh.GH_RuntimeMessageLevel.Warning, warning)
         check_data = False
     return check_data
コード例 #35
0
def unfilletCurve(curve):
    rs.EnableRedraw(False)

    curLay = rs.CurrentLayer()
    childrenLay = rs.LayerChildren(curLay)
    cutCrvs = []
    contours = []
    finalLines = []
    finalLineSegs = []
    tempCrv = curve
    if tempCrv is not None:
        cutCrvs.append(tempCrv)

    for crv in cutCrvs:
        contours.append(ghcomp.Explode(crv, True)[0])

    for contour in contours:
        for i in range(0, len(contour)):
            if rs.IsLine(contour[i]):
                finalLines.append(sc.doc.Objects.AddCurve(contour[i]))
    finalPts = []
    for line in finalLines:
        rs.ExtendCurveLength(line, 0, 2, 300)
    for i in range(0, len(finalLines) - 1):
        tempPt = rs.CurveCurveIntersection(finalLines[i], finalLines[i + 1])
        finalPts.append(rs.AddPoint(rs.coerce3dpoint(tempPt[0][1])))
    tempPt = rs.CurveCurveIntersection(finalLines[-1], finalLines[0])
    finalPts.append(rs.AddPoint(rs.coerce3dpoint(tempPt[0][1])))
    for i in range(0, len(finalPts) - 1):
        finalLineSegs.append(rs.AddLine(finalPts[i], finalPts[i + 1]))
    finalLineSegs.append(rs.AddLine(finalPts[-1], finalPts[0]))
    lastCrv = rs.JoinCurves(finalLineSegs, True)
    sc.doc.Views.Redraw()

    rs.DeleteObjects(finalPts)
    rs.DeleteObjects(finalLines)
    rs.DeleteObject(tempCrv)
    rs.DeleteObjects(cutCrvs)
    rs.EnableRedraw(True)

    rs.SelectObject(lastCrv)
コード例 #36
0
def get_sunpt(lb_sunpath,lb_preparation,lat,cpt,month,day,hourlst,north_=0,lon=0,tZ=0,scale_=100):
    """modifed from Ladybug"""
    sunpt_lst = []
    for hour in hourlst:
        centerPt = rs.coerce3dpoint(cpt)
        northAngle_, northVector = lb_preparation.angle2north(north_)
        lb_sunpath.initTheClass(lat,northAngle=northAngle_,cenPt=centerPt,\
        scale=scale_,longtitude=lon, timeZone=tZ )
        lb_sunpath.solInitOutput(month,day,hour)
        sunpt_lst.append(lb_sunpath.sunPosPt()[2]) # basePoint.Location
        #return sunSphereMesh, sunVector, basePoint.Location
    return sunpt_lst
コード例 #37
0
def get_sunpt(lb_sunpath,lb_preparation,lat,cpt,month,day,hourlst,north_=0,lon=0,tZ=0,scale_=100):
    """modifed from Ladybug"""
    sunpt_lst = []
    for hour in hourlst:
        centerPt = rs.coerce3dpoint(cpt)
        northAngle_, northVector = lb_preparation.angle2north(north_)
        lb_sunpath.initTheClass(lat,northAngle=northAngle_,cenPt=centerPt,\
        scale=scale_,longtitude=lon, timeZone=tZ )
        lb_sunpath.solInitOutput(month,day,hour)
        sunpt_lst.append(lb_sunpath.sunPosPt()[2]) # basePoint.Location
        #return sunSphereMesh, sunVector, basePoint.Location
    return sunpt_lst
コード例 #38
0
ファイル: KitsuneVault.py プロジェクト: rsarkozi/Kitsune
        def MoveGridToOrigo(treeIn, treeOut):

            RacsOrigo = GridCornerSmall(treeIn)
            RacsOrigo = rs.coerce3dpoint(RacsOrigo)

            ORIGO = rs.AddPoint(0, 0, 0)
            ORIGO = rs.coerce3dpoint(ORIGO)

            # A kiindulasi racs eltolasa

            Eltolas = ORIGO - RacsOrigo
            Eltolas = rs.coerce3dpoint(Eltolas)

            for i in range(treeIn.BranchCount):
                treeBranch = treeIn.Branch(i)
                treePath = treeIn.Path(i)

                for j in range(treeBranch.Count):
                    point = treeBranch[j] + Eltolas
                    point = rs.coerce3dpoint(point)
                    treeOut.Add(point, treePath)
コード例 #39
0
def Falls(strSrf):
    
    global p3dDropsPos
    global p3dDropProj
    
    for i in range(len(p3dDropsPos)):
        p3dProjectedPt = rs.ProjectPointToSurface(p3dDropsPos[i],strSrf,(0,0,-1))
        #print p3dProjectedPt
        if len(p3dProjectedPt)>0:
            p3dDropProj.append(rs.AddPoint(rs.coerce3dpoint(p3dProjectedPt[0])))
    if not rs.IsLayer("Drops"):
        rs.AddLayer("Drops",(30,30,255))
    rs.ObjectLayer(p3dDropProj,"Drops")
コード例 #40
0
ファイル: bula_minimal.py プロジェクト: saeranv/bibil
    def getpoints4lot(self,lots_,cpt_,value_ref_,actual_value_ref_):
        ## Loop through tree lots and add the point_nodes
        ## to each lot; returns lst of (listof points inside each lot)
        ## bpt_lst,lots: listof(listof(point data)
        debug = sc.sticky['debug']
        lst_bpt_lst_ = []
        lst_val_lst_ = []
        lst_val_lst_actual_ = []

        for j,lot in enumerate(lots_):
            boundary = lot.shape.bottom_crv
            neighbor = []
            neighbor_val= []
            neighbor_val_actual = []
            # look through all cpts from dpts and add to neighborlst
            for i,cp in enumerate(cpt_):

                movedist = abs(lot.shape.cpt[2]-cp[2])
                if abs(movedist-0.0)>0.1:
                    if lot.shape.cpt[2] < cp[2]:
                        movedist *= -1
                    vec = rc.Geometry.Vector3d(0,0,movedist)
                else:
                    vec = rc.Geometry.Vector3d(0,0,0)
                if not lot.shape.is_guid(cp):
                    cp = sc.doc.Objects.AddPoint(cp)
                copy_cp = rs.CopyObject(cp,vec)
                #copy_cp = rs.coerce3dpoint()

                #copy_cp = cp
                in_lot = 0
                try:
                    in_lot = int(rs.PointInPlanarClosedCurve(copy_cp,boundary,lot.shape.cplane))
                except:
                    pass
                #0 = point is outside of the curve
                #1 = point is inside of the curve
                #2 = point in on the curve
                if abs(float(in_lot) - 1.) <= 0.1:
                    cp = rs.coerce3dpoint(cp)
                    neighbor.append(cp)#,datalst[i]])
                    neighbor_val.append(value_ref_[i])
                    neighbor_val_actual.append(actual_value_ref_[i])
                    #d = rs.AddPoint(copy_cp[0], copy_cp[1],0)
                    #debug.append(d)
            lst_bpt_lst_.append(neighbor)
            lst_val_lst_.append(neighbor_val)
            lst_val_lst_actual_.append(neighbor_val_actual)
        return lst_bpt_lst_,lst_val_lst_,lst_val_lst_actual_
コード例 #41
0
def Flows(strSrf,step,iterations,p3dDropProj2,intCount):
    
    #New variable for setting a break point
    intCount = intCount+1
    
    #Setting lists    
    p3dDummy1 = []
    p3dUV = []
    v3dNormal = []
    v3dUni = []
    p3dDummy2 = []
    lineDummy = []
    lineProy = []
    p3dDropEnd = []
    p3dDrop = []
    lineProyTest = []
    
    #Tomamos los ptos proyectados y sacamos coordenadas
    for i in range (len(p3dDropProj2)):
        
        #obtenemos pto en srf #obtenemos su uv
        p3dDummy1.append(rs.coerce3dpoint(p3dDropProj2[i]))
        p3dUV.append(rs.SurfaceClosestPoint(strSrf,p3dDummy1[i]))
        
        #sacamos la normal en ese pto a la srf #hacemos unitario el vector #desplazamos el pto
        v3dNormal.append(rs.SurfaceNormal(strSrf,p3dUV[i]))
        v3dUni.append(rs.VectorUnitize(v3dNormal[i]))
        p3dDummy2.append(rs.PointAdd(p3dDummy1[i],v3dUni[i]))
        
        #anadimos linea #Proyectamos la linea sobre la superficie #borramos los pelos
        lineDummy.append(rs.AddLine(p3dDummy1[i],p3dDummy2[i]))
        lineProyTest.append(rs.ProjectCurveToSurface(lineDummy[i],strSrf,(0,0,-1)))
        rs.DeleteObjects(lineDummy[i])
        
        #Nueva lista eliminando los nones de la anterior (NEW! - USING FILTER)
        lineProy = filter(None,lineProyTest)
        
    for i in range (len(lineProy)):
        #Buscamos el pto final de las minicurvas para empezar a iterar
        p3dDropEnd.append(rs.CurveEndPoint(lineProy[i]))
        
    #set a Break Point
    if intCount<iterations:
        Flows(strSrf,step,iterations,p3dDropEnd,intCount)
コード例 #42
0
            pts = []
            for j in itertools.islice(lineConstrainedPoints.Branch(i),1,None):
                if j is not None: 
                    pts.append (j)
            parts = DynamicRelaxation.makeForceConstraintsFromList(ps,makePtsFromRhino(pts),makePtFromRhino(vect), False)
            allLineConstraints.append(parts)
    
    #### rail constrained points
    allRailConstraints = [] 
    for i in range(railConstrainedPoints.BranchCount):
        if len(railConstrainedPoints.Branch(i))>1 and railConstrainedPoints.Branch(i)[1] is not None:
            rail = CurveConstraint(rs.coercecurve(railConstrainedPoints.Branch(i)[0]))
            pts = []
            for j in itertools.islice(railConstrainedPoints.Branch(i),1,None):
                if j is not None: 
                    pts.append (rs.coerce3dpoint(j))
            parts, springs = DynamicRelaxation.makePositionSpringConstraintsFromList(ps, makePtsFromRhino(pts),rail.apply, 1000, 0)
            allRailConstraints.append(parts)

    #### plane constrained points
    allPlaneConstraintPoints = [] 
    for i in range(planeConstrainedPoints.BranchCount):
        if len(planeConstrainedPoints.Branch(i))>1:
            plVect = makePtFromRhino(planeConstrainedPoints.Branch(i)[0])
            pts = []
            for j in itertools.islice(planeConstrainedPoints.Branch(i),1,None):
                if j is not None: 
                    pts.append (j)
            parts = DynamicRelaxation.makeForceConstraintsFromList(ps,makePtsFromRhino(pts),plVect)
            allPlaneConstraintPoints.append(parts)
コード例 #43
0
def checkTheInputs():
    # Set default scale.
    scale = 1
    if _scale_ != None:
        if _scale_ > 0: scale = _scale_
        else:
            warning = "_scale_ must be greater than 0."
            print warning
            ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning)
            return -1
    
    # Set default sky density.
    if _skyDensity_ != None:
        if _skyDensity_ >= 0:
            skyDensity = int(_skyDensity_*100)
        else:
            warning = "skyDensity_ must be greater than 0."
            print warning
            ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning)
            return -1
    else: skyDensity = 100
    
    # Check the view point or plane.
    viewMethod = 0
    viewPlane = None
    if _centerPtOrPlane_ == None:
        centerPt = rc.Geometry.Point3d.Origin
    else:
        try:
            #The user has connected planes.
            centerPt = _centerPtOrPlane_.Origin
            viewPlane = rc.Geometry.Plane(_centerPtOrPlane_)
            viewMethod = 1
        except:
            #The user has connected points.
            try:
                centerPt = rc.Geometry.Point3d(_centerPtOrPlane_)
            except:
                try:
                    centerPt = rc.Geometry.Point3d(rs.coerce3dpoint(_centerPtOrPlane_))
                except:
                    warning = "_centerPtOrPlane_ is neither a point or a plane."
                    print warning
                    ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning)
                    return -1
    
    # Check the orientation.
    if orientation_ != None:
        if orientation_.lower() == "north":
            orientVector = rc.Geometry.Vector3d(0,1,0)
        elif orientation_.lower() == "east":
            orientVector = rc.Geometry.Vector3d(1,0,0)
        elif orientation_.lower() == "south":
            orientVector = rc.Geometry.Vector3d(0,-1,0)
        elif orientation_.lower() == "west":
            orientVector = rc.Geometry.Vector3d(-1,0,0)
        else:
            try:
                orientAngle = float(orientation_)
                if orientAngle > 360 or orientAngle < 0:
                    warning = "orientation_ must be between 0 and 360."
                    print warning
                    ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning)
                    return -1
                orientVector = rc.Geometry.Vector3d(0,1,0)
                orientVector.Rotate(math.radians(-orientAngle), rc.Geometry.Vector3d.ZAxis)
            except:
                warning = "orientation_ input is not valid."
                print warning
                ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning)
                return -1
        viewMethod = 1
        viewPlane = rc.Geometry.Plane(centerPt, orientVector)
    
    # Check the overhang, left fin, and right fin projections.
    if overhangProject_ != None:
        if overhangProject_ < 0 or overhangProject_ > 90:
            warning = "overhangProject_ should be between 0 and 90."
            print warning
            ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning)
            return -1
    if leftFinProject_ != None:
        if leftFinProject_ < 0 or leftFinProject_ > 180:
            warning = "leftFinProject_ should be between 0 and 180."
            print warning
            ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning)
            return -1
    if rightFinProject_ != None:
        if rightFinProject_ < 0 or rightFinProject_ > 180:
            warning = "rightFinProject_ should be between 0 and 180."
            print warning
            ghenv.Component.AddRuntimeMessage(gh.GH_RuntimeMessageLevel.Warning, warning)
            return -1
    
    return viewMethod, centerPt, viewPlane, scale, skyDensity
コード例 #44
0
ファイル: miru_analysis.py プロジェクト: saeranv/bibil
----------------""" 
import copy
import scriptcontext as sc
import rhinoscriptsyntax as rs
import clr

clr.AddReference("Grasshopper")
from Grasshopper.Kernel.Data import GH_Path
from Grasshopper import DataTree

if run:    
    rule = DataTree[object]()
    rule_ = [\
    ['bula', True],\
    ['grammar_key','bula'],\
    ['bula_point_lst', map(lambda pt: rs.coerce3dpoint(pt), analysis_ref)],\
    ['bula_value_lst', value_ref],\
    ['end_rule']]
    
    for i, r in enumerate(rule_):
        rule.Add(r)

else:
    rule = []






コード例 #45
0
def PlaneRemapToPlaneSpace(plane_guid, point):
    plane_obj = rs.coerceplane(plane_guid)
    (status, point) = plane_obj.RemapToPlaneSpace(rs.coerce3dpoint(point))
    return point
コード例 #46
0
ファイル: MF_00_Util.py プロジェクト: chrismay2/LaserSaur
def convertToArrayPoint3d(points):
	pArray = System.Array.CreateInstance(Rhino.Geometry.Point3d, len(points))
	arrPoints = List[System.Array[Point3d]]([pArray])
	for i in range(len(points)):
		pArray[i] = rs.coerce3dpoint(points[i])
	return arrPoints
コード例 #47
0
ファイル: Ladybug_SolarFan_alt.py プロジェクト: jtyow/ladybug
 def convert_pts(self,pt):
     rc_pt = map(lambda p: rs.coerce3dpoint(p),pt)
     return map(lambda y: Vector(y[0],y[1],y[2]),rc_pt)
コード例 #48
0
'''
Created on 16/07/2014

@author: krnj
'''

import rhinoscriptsyntax as rs


if debug:
    import pydevd as py
    py.settrace()

def midPoint(p1,p2):
    #p3 = rs.MoveObject(p1, p1+p2)
    mPt = (p1+p2)/2
    return mPt

if pt1 and pt2:
    pt1 = rs.coerce3dpoint(pt1)
    pt2 = rs.coerce3dpoint(pt2)
    a = midPoint(pt1,pt2)
    
print pt1.__getattribute__(Guid)