def InsulationPanel(left_edge, right_edge):

    points = []
    #insulation_left = ver_line_split_even[i]
    point_1 = rs.CurveStartPoint(left_edge)
    point_2 = rs.CurveEndPoint(left_edge)
    #insulation_right = ver_line_split_even[i + next_even_Cource]
    point_3 = rs.CurveEndPoint(right_edge)
    point_4 = rs.CurveStartPoint(right_edge)

    trans = rs.XformTranslation((0, 0, ipThick))
    point_5 = rs.PointTransform(point_1, trans)
    point_6 = rs.PointTransform(point_2, trans)
    point_7 = rs.PointTransform(point_3, trans)
    point_8 = rs.PointTransform(point_4, trans)

    points.append(point_1)
    points.append(point_2)
    points.append(point_3)
    points.append(point_4)
    points.append(point_5)
    points.append(point_6)
    points.append(point_7)
    points.append(point_8)

    insulation = rs.AddBox(points)

    return insulation
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 WindowFrame():

    surf_int_edge_all = rs.DuplicateSurfaceBorder(surf[1], type=2)
    print len(surf_int_edge_all)
    window_frame_all = []

    for item in range(0, len(surf_int_edge_all), 1):
        surf_int_edge = surf_int_edge_all[item]

        surf_int_edge = rs.ExplodeCurves(surf_int_edge, True)

        trans1 = rs.XformTranslation((0, 0, 2 * ipThick))
        trans2 = rs.XformTranslation((0, 0, -2 * ipThick))

        point_1 = rs.CurveStartPoint(surf_int_edge[0])
        point_2 = rs.CurveStartPoint(surf_int_edge[1])
        point_3 = rs.CurveStartPoint(surf_int_edge[2])
        point_4 = rs.CurveStartPoint(surf_int_edge[3])

        point_5 = rs.PointTransform(point_1, trans1)
        point_6 = rs.PointTransform(point_2, trans1)
        point_7 = rs.PointTransform(point_3, trans1)
        point_8 = rs.PointTransform(point_4, trans1)

        point_1 = rs.PointTransform(point_1, trans2)
        point_2 = rs.PointTransform(point_2, trans2)
        point_3 = rs.PointTransform(point_3, trans2)
        point_4 = rs.PointTransform(point_4, trans2)

        frame_points = []
        frame_points.append(point_1)
        frame_points.append(point_2)
        frame_points.append(point_3)
        frame_points.append(point_4)
        frame_points.append(point_5)
        frame_points.append(point_6)
        frame_points.append(point_7)
        frame_points.append(point_8)

        window_frame = rs.AddBox(frame_points)
        window_frame_all.append(window_frame)

    return window_frame_all
    def RunScript(self, Listener_Location, Direction, Height):

        __author__ = "theomarchal"
        self.Params.Input[
            0].Description = "Location of the listener foots (as a point - Default is set to 0,0,0)"
        self.Params.Input[
            1].Description = "Direction of the listener (in degrees from 0 to 360)"
        self.Params.Input[
            2].Description = "How tall is the listener (default = 1.80)"
        self.Params.Output[
            0].Description = "Listener Geometry, size and direction"
        self.Params.Output[
            1].Description = "Listener Object (plug it into EsquisSons)"
        self.Name = "Listener Point"
        self.NickName = "Listener"
        self.Message = "EsquisSons V3"
        self.Category = "EsquisSons"
        self.SubCategory = "1/ Scene"

        import rhinoscriptsyntax as rs

        LL = Listener_Location
        LD = Direction
        LH = Height

        if LL is None:
            LL = rs.AddPoint(0, 0, 0)
        if LD is None:
            LD = 0
        if LH is None:
            LH = 1.8

        LV = rs.VectorRotate([0, (LH), 0], LD, [0, 0, 1])
        matrix = rs.XformTranslation((0, 0, LH))
        LHp = rs.PointTransform(LL, matrix)
        LV2 = rs.VectorScale((rs.VectorRotate(LV, 90, [0, 0, 1])), 0.5)
        LV3 = rs.VectorScale((rs.VectorRotate(LV, -90, [0, 0, 1])), 0.5)
        T1 = rs.PointTransform(LL, (rs.XformTranslation(LV)))
        Tl = rs.PointTransform(LL, (rs.XformTranslation(LV2)))
        Tr = rs.PointTransform(LL, (rs.XformTranslation(LV3)))
        ps = [T1, Tl, Tr]
        Geo = [
            rs.AddSphere(LHp, (LH / 10)),
            rs.AddLine(LL, LHp),
            rs.AddSrfPt(ps)
        ]
        Tl = rs.PointTransform(Tl, matrix)
        Tr = rs.PointTransform(Tr, matrix)
        LP = [LHp, Tl, Tr, LH]
        Listener = [LP]
        return (Geo, Listener)
Example #5
0
#coding=utf-8
import rhinoscriptsyntax as rs

firstpoint = rs.GetPoint("Selet one point")  #在rhinoceros中失区点
rangel = 4  #定义x方向上复制点的数量
multiplev = 12  #定义点间距的倍数
mpoints = []  #定义第一排x方向列表

#循环x方向上复制点数量的参数,形成第一排
for i in range(rangel):
    matrix1 = rs.XformTranslation((i * multiplev, 0, 0))  #建立x方向上的矩阵
    mpoint1 = rs.PointTransform(firstpoint, matrix1)  #根据变换矩阵移动点
    mpoints.append(mpoint1)  #将移动的点依次放置于事项定义的空列表
    rs.AddPoint(mpoint1)  #在rhino空间中增加每次移动的点

rangeh = 4  #定义Y方向上复制点的次数
dpoints = {}  #定义空的字典,放置所有移动的点,每一横排的点放置于一个单独的列表中,作为值
mpointh = []  #放置所有点的空列表
deletep = []  #放置每一次内部循环即横排点的空列表,用于字典

#循环Y方向上的复制点的次数
for i in range(rangeh):
    matrixh = rs.XformTranslation((0, i * multiplev, 0))  #建立Y方向上的变换矩阵
    for m in range(len(mpoints)):
        pointh = rs.PointTransform(mpoints[m], matrixh)  #按照变换矩阵逐个移动每一个点
        rs.AddPoint(pointh)  #在rhino空间中增加每次移动点
        mpointh.append(pointh)  #将点加入列表
        deletep.append(pointh)
    dpoints[i] = deletep  #加入字典
    deletep = []
print(dpoints)
def RotateX(centerPoint, angle, pIn):
    matrix = rs.XformRotation2(angle, [0, 0, 1], centerPoint)
    return rs.PointTransform(pIn, matrix)
def MoveX(startPoint, endPoint, pIn):
    matrix = rs.XformTranslation(rs.VectorSubtract(endPoint, startPoint))
    return rs.PointTransform(pIn, matrix)
def ScaleX(startPoint, factor, pIn):
    matrix = rs.XformScale(factor, startPoint)
    return rs.PointTransform(pIn, matrix)
Example #9
0
__author__ = "billpower"
__version__ = "2019.12.27"

import rhinoscriptsyntax as rs

#start建立基本结构线
basicpoint = rs.GetPoint("pick one point")  #1.拾取一个点
matrix = rs.XformTranslation((80, 0, 0))  #建立用于移动的矩阵
mbpoint = rs.PointTransform(basicpoint, matrix)  #根据建立的矩阵移动点

basicline = rs.AddLine(basicpoint, mbpoint)  #2.建立一条直线

offsetdistance = 10
offsetlineA = rs.OffsetCurve(basicline, [0, 0, 0], offsetdistance,
                             [0, 0, 1])  #3.偏移复制直线
offsetlineB = rs.OffsetCurve(basicline, [0, 0, 0], -offsetdistance, [0, 0, 1])

#调整结构线,使用提取点移动
extendvalue = 2  #中间直线延长的距离
extendline = rs.ExtendCurveLength(basicline, 0, 2, extendvalue)  #4.延长中间直线

startpoint = rs.CurveStartPoint(extendline)  #5.拾取两侧端点
endpoint = rs.CurveEndPoint(extendline)
midpoint = rs.CurveMidPoint(extendline)

heightA = 10
heightB = 18
matrixstartend = rs.XformTranslation((0, 0, heightA))  #建立端点移动矩阵
matrixmid = rs.XformTranslation((0, 0, heightB))  #建立中间点移动矩阵

mstartpoint = rs.PointTransform(startpoint, matrixstartend)  #根据矩阵移动开始点
Example #10
0
def main():

    # get our curves
    profile, cross = get_two_curves()
    if profile is None or cross is None:
        return

    ##################################################
    # get bounding box for cross section
    
    cross_bbox = rs.BoundingBox([cross])

    

    cmin, cmax = box_to_points(cross_bbox)

    cz_range = cmax[2] - cmin[2]
    cz = 0.5 * (cmax[2] + cmin[2])

    c_ctr, _ = rs.CurveAreaCentroid(cross)

    # make sure it's planar in XY
    if cz_range > 1e-9:
        print 'cross section curve should be planar in XY plane'
        return

    ##################################################
    # get bounding box for profile
    
    profile_bbox = rs.BoundingBox([profile])

    # make sure it's planar in in YZ
    pmin, pmax = box_to_points(profile_bbox)
    
    px_range = pmax[0] - pmin[0]
    
    if px_range > 1e-9:
        print 'profile curve should be planar in YZ plane'
        return

    ##################################################
    # get the point closest to the center for the
    # cross-section curve
    
    r, pc = get_inscribed_radius(cross, c_ctr)

    ##################################################
    # get the range of z-values for the profile curve

    _, _, z0 = pmin
    _, _, z1 = pmax

    ##################################################
    # build list of rings and list of points

    points = []
    ring_pipes = []

    # for each level
    for i in range(num_levels):

        # get the Z value of the ith plane
        u = float(i) / (num_levels-1)
        z = z0 + u*(z1 - z0)

        # build the i'th plane
        plane = rs.PlaneFromNormal([0, 0, z], [0, 0, 1], [1, 0, 0])

        # find out where the plane intersects the profile curve
        intersect = rs.PlaneCurveIntersection(plane, profile)

        # there should be exactly one intersection of type 1 (point)
        if intersect is None or len(intersect) > 1 or intersect[0][0] != 1:
            print 'bad intersection'
            return

        # get the intersection point
        pi = intersect[0][1]

        # get the desired XY radius at this z value
        ri = abs(pi[1])

        # we need to set up some transformations:

        # translate cross section curve down to z=0
        T1 = rs.XformTranslation(mz.vec_mul(list(c_ctr), -1.0))

        # scale it along XY by the ratio of radii
        S1 = rs.XformScale([ri/r, ri/r, 1.0])

        # scale a piped cross section along Z by a vertical scale factor
        S2 = rs.XformScale([1.0, 1.0, ring_vscale])

        # translate piped cross section up to our desired z value
        T2 = rs.XformTranslation([0, 0, z])

        # scale and translate cross section curve
        ci = rs.TransformObject(cross, rs.XformMultiply(S1, T1), copy=True)

        # pipe it
        ring = rs.AddPipe(ci, [0, 1], [ring_rad, ring_rad])

        # scale vertically and transform up
        ring = rs.TransformObject(ring, rs.XformMultiply(T2, S2))

        # delete the copy of the cross section curve
        rs.DeleteObject(ci)

        # add to list of ring pipes
        ring_pipes.append(ring)

        # create a rotation by the i'th angle
        angle_i_deg = i*360.0/num_sides
        Ri = rs.XformRotation2(angle_i_deg, [0, 0, 1], [0, 0, 0])

        # transform the closest point by rotation and scale
        pci = rs.PointTransform(pc,
                                rs.XformMultiply(rs.XformMultiply(Ri, T2), S1))

        # add to list of points
        points.append(pci)

    # we have built up a list of points for a single spiral of struts to connect,
    # now we need to pipe them all together and do the ArrayPolar thing around
    # the z axis

    # first build a single spiral of struts
    strut_pipes = []

    for i0 in range(num_levels-1):
        i1 = i0+1
        p0 = points[i0]
        p1 = points[i1]
        l01 = rs.AddLine(p0, p1)
        pipe = rs.AddPipe(l01, [0, 1], [strut_rad, strut_rad], cap=2)
        rs.DeleteObject(l01)
        strut_pipes.append(pipe)

    # then array polar around Z axis
    all_strut_pipes = []
    all_strut_pipes += strut_pipes

    for j in range(1, num_sides):
        angle_j_deg = j*360.0/num_sides
        Rj = rs.XformRotation2(angle_j_deg, [0, 0, 1], [0, 0, 0])
        all_strut_pipes += rs.TransformObjects(strut_pipes, Rj, copy=True)

    # now just select all the objects we created
    rs.SelectObjects(ring_pipes + all_strut_pipes)

    # done!
    print 'yay'
def FixedFractureGen(n, aspect_ratio=None, sides=None):
    """
    A function to add a fixed number of circles in a cube. It also writes data 
    to fracture data text file for regenerating fracture networks.
    """
    if fracture_shape == 'circle':
        # initialize a to store fractures
        fracture_list = []
        # a loop to insert the fixed number of fractures
        for i in range(n):
            #layer name for the frcature
            layer_name = "FRACTURE_" + str(i + 1)
            #create an istance of Fracture class
            frac = Fracture()
            #store fracture name
            frac.fracture_name = layer_name
            #generate origin for fracture
            origin = GeneratePoint(boxlength)
            #store farcture center
            frac.fracture_center = origin
            #convert the origin to a plane
            plane = InclinePlane(origin)
            #add layer and color
            rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0))
            #make current layer
            rs.CurrentLayer(layer_name)
            #insert the fracture in the domain
            my_circle = rs.AddCircle(plane, radius)
            #circle_list.append(my_circle)
            surf = rs.AddPlanarSrf(my_circle)
            #delete initial fracture drawn which is a curve
            rs.DeleteObject(my_circle)
            #save fracture's GUID
            frac.fracture_GUID = surf[0]
            #append fracture into fracture list
            fracture_list.append(frac)

    elif fracture_shape == 'ellipse':
        #list to store fracture surface GUIDs
        fracture_list = []
        for i in range(n):
            #layer name for the frcature
            layer_name = "FRACTURE_" + str(i + 1)
            #create an istance of Fracture class
            frac = Fracture()
            frac.fracture_name = layer_name
            #generate fracture origin
            origin = GeneratePoint(boxlength)
            frac.fracture_center = origin
            #plane for fracture
            plane = InclinePlane(origin)
            #calculate r_y
            ry = radius / aspect_ratio
            #create layer for fracture
            rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0))
            rs.CurrentLayer(layer_name)
            #draw ellipse
            fracture = rs.AddEllipse(plane, radius, ry)
            # write the plane, r_x and r_y to file for re-plotting
            ##file.write("\n" + str(plane[0]) + "," +  str(plane[1]) + "," +  str(plane[2]) + "," + str(radius) + ","+ str(ry))
            #make fracture a surface
            frac_surf = rs.AddPlanarSrf(fracture)
            #delete initial fracture drawn which is a curve
            rs.DeleteObject(fracture)
            #append surface GUID to list of fracture surfaces
            frac.fracture_GUID = frac_surf[0]
            fracture_list.append(frac)

    elif fracture_shape == 'polygon':
        #list to store fracture surface GUIDs
        fracture_list = []
        #write the shape type
        ##file.write('\npolygon\n')
        for i in range(n):
            layer_name = "FRACTURE_" + str(i + 1)
            frac = Fracture()
            frac.fracture_name = layer_name
            #theta in radian
            theta_rad = (2 * math.pi) / sides
            #theta in degree (interior angles)
            theta_deg = theta_rad * (180 / math.pi)
            #generate origin
            origin = GeneratePoint(boxlength)
            frac.fracture_center = origin
            #create a 3D point object which isn't visible to the rhino document
            pt_01 = rs.coerce3dvector(
                [radius + origin[0], origin[1], origin[2]])
            #empty list to store all points
            points = []
            #a rotation axis
            ax = rs.coerce3dvector([0, 0, 1])
            #loop to generate points for polygon vertices
            #file.write("\n")
            for j in range(sides):
                #rotation transform with rotation from the origin
                trans = rs.XformRotation2(theta_deg * j, ax, origin)
                #transform the original 3D point and append to list
                points.append(rs.PointTransform(pt_01, trans))
            # append the initial point to close the polygon
            points.append(pt_01)
            # create layer for fracture
            # layer_name = "FRACTURE_" + str(i+1)
            rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0))
            rs.CurrentLayer(layer_name)
            # get GUID of created polygon
            polygon = rs.AddPolyline(points)
            # polygon = rs.AddPolyline(points)
            plane = InclinePlane(origin, boxlength)
            cob = rs.XformChangeBasis(rs.WorldXYPlane(), plane)
            shear2d = rs.XformIdentity()
            shear2d[0, 2] = math.tan(math.radians(45.0))
            cob_inverse = rs.XformChangeBasis(plane, rs.WorldXYPlane())
            temp = rs.XformMultiply(shear2d, cob)
            xform = rs.XformMultiply(cob_inverse, temp)
            fracture = rs.TransformObjects(polygon, xform, False)
            # make fracture a surface
            frac_surf = rs.AddPlanarSrf(fracture)
            # delete initial fracture drawn which is a curve
            rs.DeleteObject(fracture)
            frac.fracture_GUID = frac_surf[0]
            fracture_list.append(frac)
    return fracture_list
Example #12
0
def RandomFractureGen(frac_min,
                      frac_max,
                      radius_min,
                      radius_max,
                      aspect_min=None,
                      aspect_max=None,
                      polysize_min=None,
                      polysize_max=None):
    """
    Funtions to generate fractures of random number and sizes
    
    Parameters
    ----------
    frac_min: int
        minimum number of fractures to generate
    frac_max: int
        maximum number of fractures to generate
    radius_min: float
        minimum size of fractures
    radius_max: float
        maximum number of fractures to generate
    aspect_min: float
        minimum aspect ratio fpr ellipses (Default:None)
    aspect_max: float
        maximum aspect ratio fpr ellipses (Default:None)
    polysize_min: int
        minimum size of polygon (Default:None)
    polysize_max: int
        maximum size of polygon (Default:None)
    """
    # randomly determine the number of fractures to generate
    num_frac = random.randint(frac_min, frac_max)
    # open file and append to it
    file = open(path, 'a')
    if fracture_shape == 'circle':
        # write the shape type
        file.write('\ncircle')
        # initialize list to store fractures
        fracture_list = []
        # loop to generate fractures
        for i in range(num_frac):
            # name the layer
            layer_name = "FRACTURE_" + str(i + 1)
            # an instance of fracture object
            frac = Fracture()
            # get fracture name
            frac.fracture_name = layer_name
            # generate fracture center
            origin = GeneratePoint(boxlength)
            # store fracture center
            frac.fracture_center = origin
            # convert the origin to a plane
            plane = InclinePlane(origin, boxlength)
            # add layer and create color for it
            rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0))
            # make layer current layer
            rs.CurrentLayer(layer_name)
            # generate fracture size
            radius = FractureSize(size_dist, radius_min, radius_max)
            # insert the circle in the domain
            my_circle = rs.AddCircle(plane, radius)
            # write the plane and radius to file for re-plotting
            file.write("\n" + str(plane[0]) + "," + str(plane[1]) + "," +
                       str(plane[2]) + "," + str(radius))
            surf = rs.AddPlanarSrf(my_circle)
            # delete initial fracture drawn which is a curve
            rs.DeleteObject(my_circle)
            # set fracture guid into its object
            frac.fracture_GUID = surf[0]
            fracture_list.append(frac)

    elif fracture_shape == 'ellipse':
        # initialize list to store fractures
        fracture_list = []
        # write the shape type
        file.write('\nellipse')
        for i in range(num_frac):
            # name the layer
            layer_name = "FRACTURE_" + str(i + 1)
            # an instance of fracture object
            frac = Fracture()
            # get fracture name
            frac.fracture_name = layer_name
            # generate fracture center
            origin = GeneratePoint(boxlength)
            # store fracture center
            frac.fracture_center = origin
            # plane for fracture
            plane = InclinePlane(origin, boxlength)
            # randomly generate radius(rx)
            radius = FractureSize(size_dist, radius_min, radius_max)
            # randomly generate aspect ratio
            aspect_ratio = random.randint(aspect_min, aspect_max)
            # calculate r_y
            ry = radius / aspect_ratio
            # add layer with color
            rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0))
            # make current layer
            rs.CurrentLayer(layer_name)
            # draw fracture
            fracture = rs.AddEllipse(plane, radius, ry)
            # write the plane, r_x and r_y to file for re-plotting
            file.write("\n" + str(plane[0]) + "," + str(plane[1]) + "," +
                       str(plane[2]) + "," + str(radius) + "," + str(ry))
            # make fracture a surface
            frac_surf = rs.AddPlanarSrf(fracture)
            # delete initial fracture drawn which is a curve
            rs.DeleteObject(fracture)
            # set fracture guid into its object
            frac.fracture_GUID = frac_surf[0]
            # append fracture guid to list
            fracture_list.append(frac)

    elif fracture_shape == 'polygon':
        # initialize list to store fractures
        fracture_list = []
        # write the shape type
        file.write('\npolygon\n')
        for i in range(num_frac):
            # name the layer
            layer_name = "FRACTURE" + str(i + 1)
            # an instance of fracture class
            frac = Fracture()
            # get farcture name
            frac.fracture_name = layer_name
            # randomly determine the sides of the polygon
            sides = random.randint(polysize_min, polysize_max)
            # theta in radian
            theta_rad = (2 * math.pi) / sides
            # theta in degree (interior angles)
            theta_deg = theta_rad * (180 / math.pi)
            # generate origin
            origin = GeneratePoint(boxlength)
            # save fracture center
            frac.fracture_center = origin
            # randomly generate radius(rx)
            radius = FractureSize(size_dist, radius_min, radius_max)
            # create a 3D point object which isn't visible to the rhino document
            pt_01 = rs.coerce3dvector(
                [radius + origin[0], origin[1], origin[2]])
            # empty list to store all points
            points = []
            # a rotation axis
            ax = rs.coerce3dvector([0, 0, 1])
            # loop to generate points for polygon vertices
            for j in range(sides):
                # rotation transform with rotation from the origin
                trans = rs.XformRotation2(theta_deg * j, ax, origin)
                # transform the original 3D point and append to list
                points.append(rs.PointTransform(pt_01, trans))
                if j == 0:
                    file.write(
                        str(rs.PointTransform(pt_01, trans)[0]) + "," +
                        str(rs.PointTransform(pt_01, trans)[1]) + "," +
                        str(rs.PointTransform(pt_01, trans)[2]) + ",")
                if j != 0:
                    file.write(
                        str(rs.PointTransform(pt_01, trans)[0]) + "," +
                        str(rs.PointTransform(pt_01, trans)[1]) + "," +
                        str(rs.PointTransform(pt_01, trans)[2]) + ",")
            # append the initial point to close the polygon
            points.append(pt_01)
            file.write(
                str(pt_01[0]) + "," + str(pt_01[1]) + "," + str(pt_01[2]) +
                ",")
            # create layer for fracture
            layer_name = "FRACTURE_" + str(i + 1)
            rs.AddLayer(layer_name, rs.CreateColor(0, 255, 0))
            rs.CurrentLayer(layer_name)
            # get GUID of created polygon
            polygon = rs.AddPolyline(points)
            # get the plane
            plane = InclinePlane(origin, boxlength)
            # transform the polygon to the plane
            cob = rs.XformChangeBasis(rs.WorldXYPlane(), plane)
            shear2d = rs.XformIdentity()
            shear2d[0, 2] = math.tan(math.radians(45.0))
            cob_inverse = rs.XformChangeBasis(plane, rs.WorldXYPlane())
            temp = rs.XformMultiply(shear2d, cob)
            xform = rs.XformMultiply(cob_inverse, temp)
            fracture = rs.TransformObjects(polygon, xform, False)
            # write to file
            #file.write(str(origin[0]) + "," + str(origin[1]) + "," + str(origin[2])+ "," )
            file.write(
                str(plane[0]) + "," + str(plane[1]) + "," + str(plane[2]) +
                "," + str(sides) + "\n")
            # make fracture a surface
            frac_surf = rs.AddPlanarSrf(fracture)
            # delete initial fracture drawn which is a curve
            rs.DeleteObject(fracture)
            # set fracture guid into its objects
            frac.fracture_GUID = frac_surf[0]
            # append fracture guid to list
            fracture_list.append(frac)
    # close file
    file.close()
    return fracture_list