Exemple #1
0
def bspline2mask(cps, width, height, delta=0.05, scaling=5):
    connecs = []
    for i in range(len(cps)):
        curve = BSpline.Curve()
        curve.degree = 3
        curve.ctrlpts = cps[i]
        curve.knotvector = utilities.generate_knot_vector(
            curve.degree, len(curve.ctrlpts))
        # print('delta',delta)
        curve.delta = delta
        curve.evaluate()
        connecs.append(curve.evalpts)

    polygon = np.array(connecs).flatten().tolist()
    img = Image.new('L', (width, height), 255)
    ImageDraw.Draw(img).polygon(polygon, outline=0, fill=0)
    mask = np.array(
        img.resize((width // scaling, height // scaling), Image.NEAREST))
    return mask == False
Exemple #2
0
def get_b_spline(ctrl_pts):
    #########
    ctrl_pts = mvpuai.reshape_coords_to_tuples(ctrl_pts)

    def get_degree_of_b_spline(num_of_ctrl_pts: int):
        if num_of_ctrl_pts >= 5:
            degree = 4
        elif num_of_ctrl_pts >= 1:
            degree = num_of_ctrl_pts - 1
        else:
            degree = 0

        return degree

    degree = get_degree_of_b_spline(len(ctrl_pts))
    knot_vector = utilities.generate_knot_vector(degree, len(ctrl_pts))
    start = knot_vector[degree]
    stop = knot_vector[-(degree + 1)]
    return utilities.linspace(start, stop, 101, decimals=6)
Exemple #3
0
    def generateBSpline(self, curve_pts, degree):
        # Create a B-Spline curve instance
        curve = BSpline.Curve()

        # Set evaluation delta
        curve.delta = 0.001

        # Set control points
        controlpts = curve_pts
        curve.ctrlpts = controlpts

        # Set curve degree
        curve.degree = degree

        # Auto-generate knot vector
        curve.knotvector =\
            utils.generate_knot_vector(curve.degree, len(curve.ctrlpts))

        return curve, curve.knotvector
Exemple #4
0
def spline2polyline(degree, control_points, closed):
    epsilon = 1e-1
    spline = BSpline.Curve()
    spline.degree = degree
    spline.ctrlpts = control_points
    if closed:
        spline.ctrlpts += spline.ctrlpts[:spline.degree]
        m = spline.degree + len(spline.ctrlpts)
        spline.knotvector = [i / m for i in range(m + 1)]
        curve_range = (spline.knotvector[spline.degree],
                       spline.knotvector[len(spline.ctrlpts)])
        nb_seg_init = len(spline.ctrlpts)
    else:
        spline.knotvector = utilities.generate_knot_vector(
            spline.degree, len(spline.ctrlpts))
        curve_range = (0, 1)
        nb_seg_init = len(spline.ctrlpts) - 1

    t = np.linspace(curve_range[0], curve_range[1], num=nb_seg_init)
    curve_data = np.hstack((t.reshape(nb_seg_init,
                                      1), np.array(spline.evaluate_list(t))))
    curve_data = np.transpose(curve_data)
    i = 1
    while i < np.size(curve_data, 1):
        t_mid = (curve_data[0][i] + curve_data[0][i - 1]) / 2
        a = curve_data[1:, i - 1]
        b = curve_data[1:, i]
        c = spline.evaluate_single(t_mid)
        ab = b - a
        ac = c - a
        ac_proj_in_ab = np.sum(ab * ac, axis=0) / np.sum(np.square(ab), axis=0)
        dist_to_curve = np.linalg.norm(ac_proj_in_ab * ab - ac, axis=0)

        if dist_to_curve > epsilon:
            curve_data = np.insert(curve_data, i, [t_mid, c[0], c[1]], axis=1)
        else:
            i += 1
    vertices = np.insert(curve_data[1:], 2, 0., axis=0)
    if closed:
        return Polyline(vertices[:, :-1], True)
    else:
        return Polyline(vertices, False)
Exemple #5
0
def nurbs_test():
    curve = BSpline.Curve()
    curve.ctrlpts = ((3.0, ), (1.0, ), (3.0, ), (2.0, ), (5.0, ))  # 控制点
    curve.delta = 0.01  # 数据间隔
    curve.degree = 4  # degree应该小于控制点数量
    # 自动计算knot point
    curve.knotvector = utilities.generate_knot_vector(curve.degree,
                                                      len(curve.ctrlpts))
    curve.evaluate()  # 计算曲线
    pt_y = []  # y值
    pt_x = np.linspace(0, 1, 101)
    dpt_y = []  # y一阶导数
    ddpt_y = []  # y二阶导数
    for pt in pt_x:
        tmp = curve.derivatives(pt, order=2)  # 0,1,2阶导数全部计算
        pt_y.append(tmp[0][0])
        dpt_y.append(tmp[1][0])
        ddpt_y.append(tmp[2][0])
    ctrl_x = np.linspace(0, 1, 5)  # 控制点
    ctrl_y = []
    for item in curve.ctrlpts:  #
        ctrl_y.append(item[0])
    plt.plot(pt_x, pt_y, 'b-')
    plt.plot(ctrl_x, ctrl_y, 'r*')
    plt.grid()
    plt.show()
    # 验证一阶求导的正确性
    pt_y = np.array(pt_y)
    dpt_y = np.array(dpt_y)
    dpt_y_dis = (pt_y[1:] - pt_y[:-1]) / (pt_x[1] - pt_x[0])
    ddpt_y_dis = (dpt_y[1:] - dpt_y[:-1]) / (pt_x[1] - pt_x[0])
    pt_x_dis = pt_x[:-1] + (pt_x[1] - pt_x[0]) / 2
    # 绘制一阶的
    plt.plot(pt_x_dis, dpt_y_dis, '+r')
    plt.plot(pt_x, dpt_y, '-b')
    plt.show()
    # 绘制二阶的
    plt.plot(pt_x_dis, ddpt_y_dis, '+r')
    plt.plot(pt_x, ddpt_y, '-b')
    plt.show()
def generate_heart(scale=1):
    # Create a B-Spline curve
    heart = BSpline.Curve()

    # Set up the control points
    heart.degree = 3
    heart.ctrlpts = [[0, -20], [25, 5], [17, 20], [5, 19], [0.2, 13], [0, 8],
                     [-0.2, 13], [-5, 19], [-17, 20], [-25, 5], [0, -20]]

    # Scale the heart up/down according to the input scale
    heart.ctrlpts = [[scale * x, scale * y] for x, y in heart.ctrlpts]

    # Auto-generate knot vector
    heart.knotvector = utilities.generate_knot_vector(heart.degree,
                                                      len(heart.ctrlpts))

    # Set the evaluation delta
    heart.delta = 0.001

    # Evaluate the curve
    heart.evaluate()

    # Return the heart curve
    return heart
Exemple #7
0
def test_generate_knot_vector3():
    with pytest.raises(ValueError):
        degree = 0
        num_ctrlpts = 0
        utilities.generate_knot_vector(degree, num_ctrlpts)
    render_surf = False

# Fix file path
os.chdir(os.path.dirname(os.path.realpath(__file__)))

# Create a BSpline surface instance
surf = BSpline.Surface()

# Set evaluation delta
surf.delta = 0.025

# Set up surface
surf.read_ctrlpts_from_txt("ex_surface02.cpt")
surf.degree_u = 3
surf.degree_v = 3
surf.knotvector_u = utilities.generate_knot_vector(surf.degree_u, 6)
surf.knotvector_v = utilities.generate_knot_vector(surf.degree_v, 6)

# Evaluate surface
surf.evaluate()

# Draw the control point grid and the evaluated surface
if render_surf:
    vis_comp = VisMPL.VisSurfScatter()
    surf.vis = vis_comp
    surf.render()

# Save control points and evaluated curve points
surf.save_surfpts_to_csv("surfpts02_orig.csv", mode='linear')
surf.save_ctrlpts_to_csv("ctrlpts02_orig.csv", mode='wireframe')
    # Generate control points grid for Surface #1
    sg01 = CPGen.Grid(15, 10, z_value=0.0)
    sg01.generate(8, 8)

    # Create a BSpline surface instance
    surf01 = BSpline.Surface()

    # Set degrees
    surf01.degree_u = 1
    surf01.degree_v = 1

    # Get the control points from the generated grid
    surf01.ctrlpts2d = sg01.grid

    # Set knot vectors
    surf01.knotvector_u = utilities.generate_knot_vector(
        surf01.degree_u, surf01.ctrlpts_size_u)
    surf01.knotvector_v = utilities.generate_knot_vector(
        surf01.degree_v, surf01.ctrlpts_size_v)

    # Generate control points grid for Surface #2
    sg02 = CPGen.Grid(15, 10, z_value=1.0)
    sg02.generate(8, 8)

    # Create a BSpline surface instance
    surf02 = BSpline.Surface()

    # Set degrees
    surf02.degree_u = 1
    surf02.degree_v = 1

    # Get the control points from the generated grid
def createnurbsshading(idd_filename, idf_filename, base_surface, shading_str, ctrl_points, evaluated_points=20):
    ##########################################
    # loading base surface data from idf file 
    ##########################################
    
    # check if IDD has been already set
    try:
        IDF.setiddname(idd_filename)
    except modeleditor.IDDAlreadySetError as e:
        pass

    # load idf file into idf collection
    idf_collection = IDF(idf_filename)

    # find the named base_surface in idf collection
    walls = idf_collection.idfobjects['BuildingSurface:Detailed'.upper()]
    for wall in walls:
        if wall.Name == base_surface:
            # named base_surface is now contained in wall
            break
    else:
        # named base_surface was not found in idf file
        print('epnurbs.createshading: unable to find the base surface', base_surface, 'in', idf_filename)
        return

    #################################
    # calculating NURBS curve points
    #################################
    from geomdl import NURBS
    from geomdl import utilities

    curve = NURBS.Curve()

    # 1/delta corresponds to the number of trapezoids used in approximation of NURBS shading
    curve.delta = 1/evaluated_points
    curve.degree = 3

    # add weight 1 to each control point
    # unless it has been already weighted
    for cpt in ctrl_points:
        if len(cpt)<4:
            cpt.append(1.0)

    # sets curve control points
    curve.set_ctrlpts(ctrl_points)

    # sets curve knot vector
    curve.knotvector = utilities.generate_knot_vector(curve.degree, len(curve.ctrlpts))

    # evaluates curve points
    curve.evaluate()

    # make a local copy of evaluated curve points
    crv_points = curve.curvepts

    ###################################################################################
    # feet of perpendiculars from the remaining NURBS curve points to the base surface
    ###################################################################################

    # getting the found base_surface's coordinates
    coord = wall.coords
    ulc = coord[0]
    blc = coord[1]
    brc = coord[2]

    # find the base_surface's plane normal and normalize it
    N = crossproduct( (blc[0]-ulc[0], blc[1]-ulc[1], blc[2]-ulc[2]), \
                      (brc[0]-ulc[0], brc[1]-ulc[1], brc[2]-ulc[2]) )
    N = normalize(N)

    # calculate feet of perpendiculars
    feet_points = [foot(crv_points[i], ulc, N) for i in range(len(crv_points))]

    #################################################################################
    # create string of idf definitions for trapezoids that approximate NURBS shading
    #################################################################################
    idf_total_shading_def = ""
    for i in range(1, len(crv_points)):
        # the width of a trapezoid must be at least 0.01
        if distance(crv_points[i-1], crv_points[i])>=0.01 and \
           distance(feet_points[i-1], feet_points[i])>=0.01:
            # are trapezoid arms at least 0.01 or do we have a triangle?
            if distance(crv_points[i-1], feet_points[i-1])>=0.01:
                if distance(crv_points[i], feet_points[i])>=0.01:
                    # both arms are at least 0.01, so we have a trapezoid
                    vertices_str = "{:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}".format(
                                   feet_points[i-1][0], feet_points[i-1][1], feet_points[i-1][2],
                                   crv_points[i-1][0],  crv_points[i-1][1],  crv_points[i-1][2],
                                   crv_points[i][0],    crv_points[i][1],    crv_points[i][2],
                                   feet_points[i][0],   feet_points[i][1],   feet_points[i][2])
                    countervertices_str = "{:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}".format(
                                          feet_points[i][0],   feet_points[i][1],   feet_points[i][2],
                                          crv_points[i][0],    crv_points[i][1],    crv_points[i][2],
                                          crv_points[i-1][0],  crv_points[i-1][1],  crv_points[i-1][2],
                                          feet_points[i-1][0], feet_points[i-1][1], feet_points[i-1][2])
                    single_shading_def = shading_str.replace('<IDX>', str(i)).replace('<BASESURFACE>', base_surface).replace('<VERTICES>', vertices_str).replace('<COUNTERVERTICES>', countervertices_str)
                    idf_total_shading_def = idf_total_shading_def + single_shading_def
                else: 
                    # arm i is less than 0.01, so we have a triangle
                    vertices_str = "{:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}".format(
                                   feet_points[i-1][0], feet_points[i-1][1], feet_points[i-1][2],
                                   crv_points[i-1][0],  crv_points[i-1][1],  crv_points[i-1][2],
                                   feet_points[i][0],   feet_points[i][1],   feet_points[i][2])
                    countervertices_str = "{:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}".format(
                                          feet_points[i][0],   feet_points[i][1],   feet_points[i][2], 
                                          crv_points[i-1][0],  crv_points[i-1][1],  crv_points[i-1][2],
                                          feet_points[i-1][0], feet_points[i-1][1], feet_points[i-1][2])               
                    single_shading_def = shading_str.replace('<IDX>', str(i)).replace('<BASESURFACE>', base_surface).replace('<VERTICES>', vertices_str).replace('<COUNTERVERTICES>', countervertices_str)
                    idf_total_shading_def = idf_total_shading_def + single_shading_def
            else:
                # arm i-1 is less than 0.01, but do we still have a triangle?
                if distance(crv_points[i], feet_points[i])>=0.01:
                    # we have a triangle
                    vertices_str = "{:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}".format(
                                   feet_points[i-1][0], feet_points[i-1][1], feet_points[i-1][2],
                                   crv_points[i][0],    crv_points[i][1],    crv_points[i][2],
                                   feet_points[i][0],   feet_points[i][1],   feet_points[i][2])
                    countervertices_str = "{:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}, {:f}".format(
                                          feet_points[i][0],   feet_points[i][1],   feet_points[i][2],
                                          crv_points[i][0],    crv_points[i][1],    crv_points[i][2],
                                          feet_points[i-1][0], feet_points[i-1][1], feet_points[i-1][2])              
                    single_shading_def = shading_str.replace('<IDX>', str(i)).replace('<BASESURFACE>', base_surface).replace('<VERTICES>', vertices_str).replace('<COUNTERVERTICES>', countervertices_str)
                    idf_total_shading_def = idf_total_shading_def + single_shading_def
                else:
                    # we do not have a shading element in this case
                    pass
    
    # create idf shading objects from the string containing shading definitions   
    from io import StringIO
    idf_shading = IDF(StringIO(idf_total_shading_def))

    # copy idf shading objects to the existing idf file
    shadings = idf_shading.idfobjects["SHADING:ZONE:DETAILED"]
    for shading in shadings:
        idf_collection.copyidfobject(shading)

    ###############################
    # at the end, save the changes
    ###############################
    idf_collection.save()
Exemple #11
0
def plot_base(ctrlpts_size_u, Bspl):
    type = ['closed', 'open', 'nonlinear', 'special', 'special2', 'special3']
    # fig = plt.figure()
    # ax = fig.gca()
    color = ['r', 'b', 'k', 'g', 'c', 'm', 'y', 'r', 'b', 'k', 'g', 'c', 'm', 'y', 'r', 'b', 'k', 'g', 'c', 'm', 'y']
    for ind, setup in enumerate(type):

        if setup == 'open':
            Bspl.knotvector_u = tuple(np.linspace(0, 1, num=Bspl.degree_u + ctrlpts_size_u + 1).tolist())

            # span_u = helpers.find_span_linear(Bspl.degree_u, Bspl.knotvector_u, ctrlpts_size_u, 1)
            # # span_u = self._span_func(Bspl.degree_u, Bspl.knotvector_u, ctrlpts_size_u, 1)
            # bfunsders_u = helpers.basis_function_ders(Bspl.degree_u, Bspl.knotvector_u, span_u, 1, 0)


        elif setup == 'closed':
            Bspl.knotvector_u = geom_util.generate_knot_vector(Bspl.degree_u, ctrlpts_size_u)

        elif setup == 'nonlinear':
            pdb.set_trace()
            numb = Bspl.degree_u + ctrlpts_size_u + 1
            vec = np.linspace(0.1, 1, num=np.floor(numb / 2)).tolist()

            k = 0.5
            vec = [elem ** k for elem in vec]
            # vec = np.exp(vec)
            # Normalize
            vec = vec / (2 * np.max(vec))

            if numb % 2 == 0:
                # Do not append mid number if uneven number of points!
                lst = np.sort(np.append(vec, -vec)) + 0.5
            else:
                lst = np.sort(np.append(np.append(vec, 0), -vec)) + 0.5
            Bspl.knotvector_u = tuple(lst)

        elif setup == 'special':
            # closed knotvector
            pdb.set_trace()
            c_kn = np.linspace(0, 1, num=Bspl.degree_u + ctrlpts_size_u + 1).tolist()

            c_kn[0] = c_kn[1]
            c_kn[-1] = c_kn[-2]

            Bspl.knotvector_u = c_kn

        elif setup == 'special2':
            c_kn = np.linspace(0, 1, num=Bspl.degree_u + ctrlpts_size_u + 1).tolist()

            # Closed. nothing fishy
            c_kn[0] = c_kn[2]
            c_kn[1] = c_kn[2]
            c_kn[-1] = c_kn[-3]
            c_kn[-2] = c_kn[-3]
            Bspl.knotvector_u = c_kn

        elif setup == 'special3':
            c_kn = np.linspace(0, 1, num=Bspl.degree_u + ctrlpts_size_u + 1).tolist()
            pdb.set_trace()
            # Closed. nothing fishy
            c_kn[0] = c_kn[2]
            c_kn[1] = c_kn[2]
            c_kn[-1] = c_kn[-3]
            c_kn[-2] = c_kn[-3]
            Bspl.knotvector_u = c_kn
        else:
            raise NotImplementedError

        start_u = Bspl._knot_vector_u[Bspl._degree_u]
        stop_u = Bspl._knot_vector_u[-(Bspl._degree_u + 1)]

        # Map variables to valid knot space
        knots_u = start_u + (stop_u - start_u) * np.linspace(0, 1, 100)

        spans_p = helpers.find_spans(Bspl.degree_u, Bspl.knotvector_u, ctrlpts_size_u, knots_u, Bspl._span_func)
        basis_p = helpers.basis_functions(Bspl.degree_u, Bspl.knotvector_u, spans_p, knots_u)

        basis_p_full = np.array(basis_full(Bspl, basis_p, Bspl.degree_u, spans_p))

        # Plot the curve
        fig = plt.figure()
        ax = fig.gca()
        i = 0
        # Bspl.derivatives(1, 1, 0)

        # plot derivative
        bfun_der = []
        basis_p_full = np.array(basis_full(Bspl, basis_p, Bspl.degree_u, spans_p))

        for knot in knots_u:
            span_u = helpers.find_span_linear(Bspl.degree_u, Bspl.knotvector_u, ctrlpts_size_u, knot)
            row = helpers.basis_function_ders(Bspl.degree_u, Bspl.knotvector_u, span_u, knot, 2)[-1]
            # pdb.set_trace()
            bfun_der.append(row)

        der_plot = np.array(basis_full(Bspl, bfun_der, Bspl.degree_u, spans_p))
        # plot the value of the function

        for ind, dummy in enumerate(basis_p_full[0]):
            max_val = np.max(np.abs(der_plot[:, i]))
            ax.plot(knots_u, np.ravel(basis_p_full[:, i]), color[ind])
            ax.plot(knots_u, np.ravel(der_plot[:, i]) * (stop_u - start_u), '--o' + color[ind])  # / np.max(der_plot[:, i])
            i += 1
        ax.set_title(setup)
        plt.show()
Exemple #12
0
    render_curve = False

r = 3.0
Cx = lambda t: r + r * math.cos(0.5 * math.pi * t + math.pi)
Cy = lambda t: r + r * math.sin(0.5 * math.pi * t + math.pi)

# choose curve parameter
degree = 2
nCtrlpts = 3

# gauss quadrature
xi = [-0.90618, -0.538469, 0, 0.538469, 0.90618]
wi = [0.236927, 0.478629, 0.568889, 0.478629, 0.236927]

# solve
knotvector = utils.generate_knot_vector(degree, nCtrlpts)
span = lambda xi: utils.find_span(degree, tuple(knotvector), nCtrlpts, xi * 0.5
                                  + 0.5)
bfuns = lambda xi: utils.basis_functions(2, tuple(knotvector), span(xi), xi *
                                         0.5 + 0.5)

t = -0.5
print knotvector
print span(t)
print bfuns(t)

A = np.zeros((nCtrlpts, nCtrlpts))
A_temp = np.zeros((nCtrlpts, nCtrlpts))

B = np.zeros(3)
for g in range(0, len(xi)):
Exemple #13
0
                                        coords_disp[i, 0], coords_disp[i, 1]))

f.close()

# Visualize results (displacement only)

# Visualize minimization results
# Set up new surface
disp_surf = bs.Surface()

disp_surf.degree_u = 3
disp_surf.degree_v = 3

disp_surf.set_ctrlpts(coords_disp.tolist(), num_ctrlpts, num_ctrlpts)

disp_surf.knotvector_u = gutil.generate_knot_vector(disp_surf.degree_u,
                                                    num_ctrlpts)
disp_surf.knotvector_v = gutil.generate_knot_vector(disp_surf.degree_v,
                                                    num_ctrlpts)

disp_surf.delta = 0.01
fname = 'sinusoidalxmindispl'
visualize.viz_displacement(def_image, disp_surf, indices[0], indices[1],
                           indices[2], indices[3], fname)

# Compute differences between proscribed and actual displacement measurements
# Fill x and y displacement arrays
U_diff = np.zeros(def_image.shape) * np.nan
V_diff = np.zeros(def_image.shape) * np.nan
rowmin_index = indices[0]
rowmax_index = indices[1]
colmin_index = indices[2]
Exemple #14
0
def main():
    points = np.loadtxt("N2_RV_P0.txt")

    zmin_loc_temp = np.where(points[:, 1] == 0)[0]
    zmin_loc = zmin_loc_temp

    # points = remove_3dpoint(points,zmin_loc)
    N = 5
    slice(N, points)

    slice0 = slice.slices[0]
    x0 = slice0[:, 0]
    y0 = slice0[:, 1]
    z0 = slice0[:, 2]
    slice1 = slice.slices[1]
    x1 = slice1[:, 0]
    y1 = slice1[:, 1]
    z1 = slice1[:, 2]
    slice2 = slice.slices[2]
    x2 = slice2[:, 0]
    y2 = slice2[:, 1]
    z2 = slice2[:, 2]
    slice3 = slice.slices[3]
    x3 = slice3[:, 0]
    y3 = slice3[:, 1]
    z3 = slice3[:, 2]
    slice4 = slice.slices[4]
    x4 = slice4[:, 0]
    y4 = slice4[:, 1]
    z4 = slice4[:, 2]
    print(np.shape(points))
    ranges = slice.bins

    diameter = x0.max() - x0.min()
    radius = diameter
    height = z0.max()

    diameter1 = x1.max() - x1.min()
    radius1 = diameter1
    height1 = z1.max()

    diameter2 = x2.max() - x2.min()
    radius2 = diameter2
    height2 = z2.max()

    diameter3 = x3.max() - x3.min()
    radius3 = diameter3
    height3 = z3.max()

    diameter4 = x4.max() - x4.min()
    radius4 = diameter4 / 2
    height4 = x4.max()

    # Generate a cylindrical surface using the shapes component
    cylinder = surface.cylinder(radius, height)
    # vis_config = VisMPL.VisConfig(ctrlpts=True)
    # vis_comp = VisMPL.VisSurface(config=vis_config)
    # cylinder.vis = vis_comp
    # cylinder.render()
    cyl_points = cylinder.evalpts
    print("*****************")
    # print(len(cyl_points))
    print("*****************")

    cylinder1 = surface.cylinder(radius1, height1)
    cyl_points1 = cylinder1.evalpts
    # vis_config = VisMPL.VisConfig(ctrlpts=True)
    # vis_comp = VisMPL.VisSurface(config=vis_config)
    # cylinder1.vis = vis_comp
    # cylinder1.render()

    cylinder2 = surface.cylinder(radius2, height2)
    cyl_points2 = cylinder2.evalpts
    # vis_config = VisMPL.VisConfig(ctrlpts=True)
    # vis_comp = VisMPL.VisSurface(config=vis_config)
    # cylinder2.vis = vis_comp
    # cylinder2.render()

    cylinder3 = surface.cylinder(radius3, height3)
    cyl_points3 = cylinder3.evalpts
    # vis_config = VisMPL.VisConfig(ctrlpts=True)
    # vis_comp = VisMPL.VisSurface(config=vis_config)
    # cylinder2.vis = vis_comp
    # cylinder2.render()

    cylinder4 = surface.cylinder(radius4, height4)
    cyl_points4 = cylinder4.evalpts
    # vis_config = VisMPL.VisConfig(ctrlpts=True)
    # vis_comp = VisMPL.VisSurface(config=vis_config)
    # cylinder4.vis = vis_comp
    # cylinder4.render()

    #try using points from the surface not the control points
    cylinder_cpts = np.array(cylinder.ctrlpts)
    cylinder_cpts1 = np.array(cylinder1.ctrlpts)
    cylinder_cpts2 = np.array(cylinder2.ctrlpts)
    cylinder_cpts3 = np.array(cylinder3.ctrlpts)
    cylinder_cpts4 = np.array(cylinder4.ctrlpts)

    a = np.array(cdist(np.array(cyl_points), slice0)).min(axis=0)
    b = np.array(cdist(np.array(cyl_points1), slice1)).min(axis=0)
    c = np.array(cdist(np.array(cyl_points2), slice2)).min(axis=0)
    d = np.array(cdist(np.array(cyl_points3), slice3)).min(axis=0)
    e = np.array(cdist(np.array(cyl_points4), slice4)).min(axis=0)

    test = np.zeros((len(cylinder_cpts), 3))
    test1 = np.zeros((len(cylinder_cpts1), 3))
    test2 = np.zeros((len(cylinder_cpts2), 3))
    test3 = np.zeros((len(cylinder_cpts3), 3))
    test4 = np.zeros((len(cylinder_cpts4), 3))

    for i in range(0, len(cylinder_cpts)):
        test[i] = (cylinder_cpts[i] / np.linalg.norm(cylinder_cpts[i])) * a[i]
        test1[i] = (cylinder_cpts1[i] /
                    np.linalg.norm(cylinder_cpts1[i])) * b[i]
        test2[i] = (cylinder_cpts2[i] /
                    np.linalg.norm(cylinder_cpts2[i])) * c[i]
        test3[i] = (cylinder_cpts3[i] /
                    np.linalg.norm(cylinder_cpts3[i])) * d[i]
        test4[i] = (cylinder_cpts4[i] /
                    np.linalg.norm(cylinder_cpts4[i])) * e[i]

    test_zeros_loc = np.where(test[:, 2] == 0)[0]
    test1_zeros_loc = np.where(test1[:, 2] == 0)[0]
    test2_zeros_loc = np.where(test2[:, 2] == 0)[0]
    test3_zeros_loc = np.where(test3[:, 2] == 0)[0]
    test4_zeros_loc = np.where(test4[:, 2] == 0)[0]

    test = remove_3dpoint(test, test_zeros_loc)
    test1 = remove_3dpoint(test1, test1_zeros_loc)
    test2 = remove_3dpoint(test2, test2_zeros_loc)
    test3 = remove_3dpoint(test3, test3_zeros_loc)
    test4 = remove_3dpoint(test4, test4_zeros_loc)

    test = np.array(
        [test[:, 0], test[:, 1],
         np.ones(len(test[:, 2])) * ranges[0]]).T
    test1 = np.array(
        [test1[:, 0], test1[:, 1],
         np.ones(len(test1[:, 2])) * ranges[1]]).T
    test2 = np.array(
        [test2[:, 0], test2[:, 1],
         np.ones(len(test2[:, 2])) * ranges[2]]).T
    test3 = np.array(
        [test3[:, 0], test3[:, 1],
         np.ones(len(test3[:, 2])) * ranges[3]]).T
    test4 = np.array(
        [test4[:, 0], test4[:, 1],
         np.ones(len(test4[:, 2])) * ranges[4]]).T

    # for i in range(0,len(test1)):
    # test1[i] = test1[i] + [0,0,height]
    # test2[i] = test2[i]+[0,0,height1]
    # test3[i] = test3[i]+[0,0,height2]

    test = remove_3dpoint(test, len(test) - 1)
    test1 = remove_3dpoint(test1, len(test1) - 1)
    test2 = remove_3dpoint(test2, len(test2) - 1)
    test3 = remove_3dpoint(test3, len(test3) - 1)
    test4 = remove_3dpoint(test4, len(test4) - 1)

    # test = np.insert(test,[0,len(test)],[[0,0,-5],[0,0,ranges[0]]],axis=0)
    # test1 = np.insert(test1,[0,len(test1)],[0,0,ranges[1]],axis=0)
    # test2 = np.insert(test2,[0,len(test2)],[0,0,ranges[2]],axis=0)
    test = np.insert(
        test,
        [len(test) - 2, len(test) - 1, len(test)], [test[0], test[1], test[2]],
        axis=0)
    test1 = np.insert(
        test1, [len(test1) - 2, len(test1) - 1,
                len(test1)], [test1[0], test1[1], test1[2]],
        axis=0)
    test2 = np.insert(
        test2, [len(test2) - 2, len(test2) - 1,
                len(test2)], [test2[0], test2[1], test2[2]],
        axis=0)
    test3 = np.insert(
        test3, [len(test3) - 2, len(test3) - 1,
                len(test3)], [test3[0], test3[1], test3[2]],
        axis=0)
    test = np.insert(
        test4, [len(test4) - 2, len(test4) - 1,
                len(test4)], [test4[0], test4[1], test4[2]],
        axis=0)

    # print(test)
    # print(test1)
    # print(test2)
    # print(test3)

    X = np.row_stack((test, test1, test2, test3, test4))
    print(X)
    # np.random.shuffle(X)

    np.savetxt("cpts_test.csv", X, delimiter=",")
    # np.savetxt("cpts_test1.csv", test1, delimiter=",")
    fig = plt.figure()
    ax = plt.axes(projection="3d")
    ax.scatter3D(test[:, 0],
                 test[:, 1],
                 np.ones(len(test[:, 2])) * ranges[0],
                 color='red')
    ax.scatter3D(test1[:, 0], test1[:, 1], test1[:, 2], color='blue')
    ax.scatter3D(test2[:, 0], test2[:, 1], test2[:, 2], color='green')
    ax.scatter3D(test3[:, 0], test3[:, 1], test3[:, 2], color='yellow')
    ax.scatter3D(test4[:, 0], test4[:, 1], test4[:, 2], color='purple')
    # ax.scatter3D(cylinder_cpts[:,0],cylinder_cpts[:,1],cylinder_cpts[:,2])
    # ax.scatter3D(cylinder_cpts1[:,0],cylinder_cpts1[:,1],cylinder_cpts1[:,2])

    # try fitting a NURBS Surface
    surf = NURBS.Surface()
    surf.delta = 0.03
    p_ctrlpts = exchange.import_csv("cpts_test.csv")
    print(len(p_ctrlpts))
    p_weights = np.ones((len(p_ctrlpts)))
    p_size_u = 9
    p_size_v = 5
    p_degree_u = 3
    p_degree_v = 3
    t_ctrlptsw = compat.combine_ctrlpts_weights(p_ctrlpts, p_weights)
    n_ctrlptsw = compat.flip_ctrlpts_u(t_ctrlptsw, p_size_u, p_size_v)
    n_knotvector_u = utils.generate_knot_vector(p_degree_u, p_size_u)
    n_knotvector_v = utils.generate_knot_vector(p_degree_v, p_size_v)

    surf.degree_u = p_degree_u
    surf.degree_v = p_degree_v
    surf.set_ctrlpts(n_ctrlptsw, p_size_u, p_size_v)
    surf.knotvector_u = n_knotvector_u
    surf.knotvector_v = n_knotvector_v
    vis_config = vis.VisConfig(ctrlpts=True, axes=True, legend=True)
    surf.vis = vis.VisSurface(vis_config)
    surf.evaluate()
    surf.render()
Exemple #15
0
 def swing_curve_planning(self, leg_down):
     # 1. 现在是哪条腿落下
     if leg_down is 'left':
         coe = -1
     else:
         coe = 1
     # ---------------------------------
     # 2. 首先处理当前准备触地的腿
     p_end, a_end = self.p_end, self.a_end
     a_begin = np.array([a_end[0], a_end[1], -a_end[2]])   # 这是重规划的起始点
     p_begin = np.array([-p_end[0], p_end[1], p_end[2]])
     # 2.1 直角坐标空间下的关键点位置
     p1 = tuple(p_begin)
     p2 = tuple(p_begin + 0.1 * a_begin)
     p4 = tuple(p_end - 0.05 * a_end)
     p5 = tuple(p_end)
     p3 = (0., (p1[1]+p5[1])/2, p_begin[2] + 0.3)
     # 2.2 关节坐标空间下的关键点位置转化
     jp1 = self.coord_fake_world2joint(np.array(p1).reshape((3, 1)), leg_down)
     jp2 = self.coord_fake_world2joint(np.array(p2).reshape((3, 1)), leg_down)
     jp3 = self.coord_fake_world2joint(np.array(p3).reshape((3, 1)), leg_down)
     jp4 = self.coord_fake_world2joint(np.array(p4).reshape((3, 1)), leg_down)
     jp5 = self.coord_fake_world2joint(np.array(p5).reshape((3, 1)), leg_down)
     # 2.3 构造曲线对象
     tmp_curve = BSpline.Curve()
     tmp_curve.ctrlpts = (jp1, jp2, jp3, jp4, jp5)
     tmp_curve.delta = 0.01
     tmp_curve.degree = 4
     tmp_curve.knotvector = utilities.generate_knot_vector(4, len(tmp_curve.ctrlpts))
     tmp_curve.evaluate()
     if leg_down is 'left':
         self.this_curve_l = tmp_curve
     else:
         self.this_curve_r = tmp_curve
     # ----------------------------
     # 3. 让我们来处理另一条腿吧
     p_end = np.array([p_end[0], coe*0.12, p_end[2]])  #
     a_end = np.array([a_end[0], 0.0, a_end[2]])       # 方向向前
     if self.cycle_cnt == 1:
         p_begin = np.array([-p_end[0], p_end[1], p_end[2]])    # x位置反向
         a_begin = np.array([a_end[0], a_end[1], -a_end[2]])    # z方向相反
     else:
         p_begin = self.p_begin
         a_begin = self.a_begin
     # 3.1 直角坐标系下的关键点位置
     p1 = tuple(p_begin)
     p2 = tuple(p_begin + 0.1 * a_begin)
     p4 = tuple(p_end - 0.05 * a_end)
     p5 = tuple(p_end)
     p3 = (0., (p1[1] + p5[1]) / 2, p_begin[2] + 0.3)
     # 3.2 关节坐标空间下的关键点位置转化
     jp1 = self.coord_fake_world2joint(np.array(p1).reshape((3, 1)), leg_down)
     jp2 = self.coord_fake_world2joint(np.array(p2).reshape((3, 1)), leg_down)
     jp3 = self.coord_fake_world2joint(np.array(p3).reshape((3, 1)), leg_down)
     jp4 = self.coord_fake_world2joint(np.array(p4).reshape((3, 1)), leg_down)
     jp5 = self.coord_fake_world2joint(np.array(p5).reshape((3, 1)), leg_down)
     # 3.3 构造曲线对象
     tmp_curve = BSpline.Curve()
     tmp_curve.ctrlpts = (jp1, jp2, jp3, jp4, jp5)
     tmp_curve.delta = 0.01
     tmp_curve.degree = 4
     tmp_curve.knotvector = utilities.generate_knot_vector(4, len(tmp_curve.ctrlpts))
     tmp_curve.evaluate()
     if leg_down is 'left':
         self.this_curve_r = tmp_curve
     else:
         self.this_curve_l = tmp_curve
Exemple #16
0
def test_check_knot_vector4():
    degree = 4
    num_ctrlpts = 12
    autogen_kv = utilities.generate_knot_vector(degree, num_ctrlpts)
    check_result = utilities.check_knot_vector(degree=degree, num_ctrlpts=num_ctrlpts, knot_vector=autogen_kv)
    assert check_result
Exemple #17
0
def test_generate_knot_vector4():
    degree = 4
    num_ctrlpts = 12
    autogen_kv = utilities.generate_knot_vector(degree, num_ctrlpts)
    result = [0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0, 1.0, 1.0, 1.0, 1.0]
    assert autogen_kv == result
Exemple #18
0
#
# 2D CURVE 1
#

# Create a B-Spline curve instance (Bezier Curve)
curve1 = BSpline.Curve()

# Set evaluation delta
curve1.delta = 0.01

# Set up the Bezier curve
curve1.ctrlpts = [[10, 0], [15, 15], [20, 0]]
curve1.degree = 2

# Auto-generate knot vector
curve1.knotvector = utilities.generate_knot_vector(curve1.degree,
                                                   len(curve1.ctrlpts))

# Evaluate curve
curve1.evaluate()

# Draw the control point polygon and the evaluated curve
if render_curve:
    vis_comp1 = VisMPL.VisCurve2D()
    curve1.vis = vis_comp1
    curve1.render()

#
# 2D CURVE 2
#

# Create another B-Spline curve instance (Bezier Curve)
Exemple #19
0
from geomdl import utilities
import numpy as np
degree = 4
Ncpts = 9

ti = utilities.generate_knot_vector(degree,Ncpts+1)



P = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,19,20,21,22,23,24,25,26,51,52,53,54,55,56,57,58,59,60]


def getABsis(cpt,ti,t):
    if t>=ti[cpt] and t<ti[cpt+1]:
        return 1
    else:
        return 0

Nij=np.zeros([len(P),Ncpts+2+degree,degree+1])

for deg in range(degree+1):
    if deg == 0:
        for cpt in range(Ncpts+degree+1):
            for pt,t in enumerate(P):
                Nij[pt][cpt][deg] = getABsis(cpt,ti,t/P[-1])
    else:
        for cpt in range(Ncpts+degree+2-deg):
            for pt,t in enumerate(P):
                try:
                    LEFT = (t/P[-1] - ti[cpt]) / (ti[cpt+deg]-ti[cpt])
                    RIGHT = (ti[cpt+deg+1] - t/P[-1]) / (ti[cpt+deg+1]-ti[cpt+1])
Exemple #20
0
# Weights of the control points
p_weights = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

# Degrees
p_degree_u = 3
p_degree_v = 2

#
# Prepare data for import
#

t_ctrlptsw = compat.combine_ctrlpts_weights(p_ctrlpts, p_weights)
n_ctrlptsw = compat.flip_ctrlpts_u(t_ctrlptsw, p_size_u, p_size_v)

# Since we have no information on knot vectors, let's auto-generate them
n_knotvector_u = utils.generate_knot_vector(p_degree_u, p_size_u)
n_knotvector_v = utils.generate_knot_vector(p_degree_v, p_size_v)

#
# Import surface to NURBS-Python
#

surf = NURBS.Surface()
surf.degree_u = p_degree_u
surf.degree_v = p_degree_v
surf.ctrlpts_size_u = p_size_u
surf.ctrlpts_size_v = p_size_v
surf.ctrlptsw = n_ctrlptsw
surf.knotvector_u = n_knotvector_u
surf.knotvector_v = n_knotvector_v
    def smooth_bspline(self, filename):
        """
        Smooth respiratory function using B-spline curve

        Parameters
        ----------
        filname: string
            Name of 2DST file to smooth the respiratory function

        Returns
        -------
        snake: list
            Optimised B-spline curve (respiratory function smoothed)
        """

        # Recover respiratory function extracted from 2DST images using masks
        ldiaphragm_pts = [list(item) for item in self.respiratory_pattern(filename)]
        # print("Original diaphragm points: {}".format(ldiaphragm_pts))

        # img = cv2.imread('{}/{}/{}/{}'.format(DIR_2DST_DICOM, self.patient, self.plan, filename), 1)
        # diaphragm_mask = np.zeros((256, 50, 3), np.uint8)
        # img_mask = img.copy()
        # i = 0
        # while(i < len(ldiaphragm_pts) - 1):
        #     cv2.line(
        #         img_mask,
        #         ldiaphragm_pts[i], ldiaphragm_pts[i + 1],
        #         (255, 0, 0), 1)
        #     i = i + 1
        # cv2.imshow('Diaphragmatic level', img_mask)
        # cv2.waitKey(0)
        # cv2.destroyAllWindows()
        # cv2.imwrite('name.png', img_mask)

        # Try to load the visualization module
        try:
            render_curve = True
            from geomdl.visualization import VisMPL
        except ImportError:
            render_curve = False

        # Create a B-Spline curve instance
        curve = BSpline.Curve()

        # Set evaluation delta
        curve.delta = 0.0002

        """ Set up curve """
        # Set control points
        controlpts = ldiaphragm_pts
        convert_controlpts = map(lambda x: 255 - x[1], controlpts)
        for i in range(len(controlpts)):
            controlpts[i][1] = convert_controlpts[i]

        curve.ctrlpts = controlpts

        # Set curve degree
        curve.degree = 3

        # Auto-generate knot vector
        curve.knotvector =\
            utilities.generate_knot_vector(
                curve.degree, len(curve.ctrlpts))

        # Evaluate curve
        curve.evaluate()

        # Draw the control point polygon and the evaluated curve
        if render_curve:
            vis_comp = VisMPL.VisCurve2D()
            curve.vis = vis_comp
            curve.render()
Exemple #22
0
               bump_height=45,
               base_extent=4,
               base_adjust=1)

# Create a BSpline surface instance
surf = BSpline.Surface()

# Set degrees
surf.degree_u = 3
surf.degree_v = 3

# Get the control points from the generated grid
surf.ctrlpts2d = surfgrid.grid()

# Set knot vectors
surf.knotvector_u = utilities.generate_knot_vector(surf.degree_u,
                                                   surf.ctrlpts_size_u)
surf.knotvector_v = utilities.generate_knot_vector(surf.degree_v,
                                                   surf.ctrlpts_size_v)

# Split the surface at v = 0.35
split_surf = surf.split_v(0.35)

# Set sample size of the split surface
split_surf.sample_size = 25

# Generate the visualization component and its configuration
vis_config = VisPlotly.VisConfig(ctrlpts=False, legend=False)
vis_comp = VisPlotly.VisSurface(vis_config)

# Set visualization component of the split surface
split_surf.vis = vis_comp
Exemple #23
0
    def draw_graph(self,
                   output_file,
                   style,
                   size=1.0,
                   scale_correction=900,
                   curved=False,
                   symbology=True,
                   label_correction=1.0,
                   node_scale=5,
                   offset=(0, 0)):
        """
        output_file: path to an svg file
        style: a python dictionary defining the styles for nodes and edges
        size: default size is 2000 * 2000 multiplied by the size value
        scale_correction: change this value to alter the size of the graph relative to the total size of the svg canvas
        curved: whether edge connections are curved or not
        symbology: whether or not to use symbology when drawing the graph or a colour scheme
        label_correction: adjusts the position of the labels relative to the centre of the nodes
        node_scale: the size of the nodes relative to canvas
        offset: x y coordinates to offset the centre of the graph - useful when using a background image (as defined in the style)
        """

        dwg_size = (2000 * size, 2000 * size)

        dwg = svgwrite.Drawing(filename=output_file,
                               size=dwg_size,
                               profile='full',
                               debug=True)

        rect = dwg.rect(insert=(0, 0),
                        size=dwg_size,
                        fill=style['background']['color'])

        dwg.add(rect)

        if style['background'].get('image') is not None:
            path = style['background'].get('image')
            img = Image(filename=path)
            img_data = img.make_blob(format='png')
            encoded = base64.b64encode(img_data).decode()
            png_data = 'data:image/png;base64,{}'.format(encoded)
            image = dwg.add(
                dwg.image(href=(png_data),
                          insert=(0, 0),
                          size=dwg_size,
                          opacity=style['background']['opacity']))

        ## Scale the graph to fit the svg canvas

        # First, find the bounds of the graph

        maxX = 0
        maxY = 0
        minX = 0
        minY = 0

        for node, data in self.nodes.items():
            x = float(data['x'])
            y = float(data['y'])
            if (maxX == 0 and maxY == 0 and minX == 0 and minY == 0):
                maxX = x
                maxY = y
                minX = x
                minY = y
            if x > maxX:
                maxX = x
            if y > maxY:
                maxY = y
            if x < minX:
                minX = x
            if y < minY:
                minY = y

        scale = (max(scale_correction / maxX, scale_correction / maxY)) * size

        # Then calculate the transformation to fit the nodes on the canvas

        for node, data in self.nodes.items():
            # Translate and scale nodes
            x = float(data['x'])
            y = float(data['y'])

            x -= (maxX + minX) / 2
            y -= (maxY + minY) / 2

            x *= scale
            y *= scale

            x += 1050 * size
            y += 1050 * size

            y = (2050 * size) - y

            # Store translated coordinates, with x,y offset

            data['x'] = x + offset[0]
            data['y'] = y + offset[1]

        ## Draw the edges

        edges_group = dwg.add(dwg.g())

        for edge, data in self.edges.items():

            # Pull out the sources and targets

            source = data['source']
            target = data['target']

            # Find the coordinates of each source and target

            start = (self.nodes[source]['x'], self.nodes[source]['y'])
            end = (self.nodes[target]['x'], self.nodes[target]['y'])

            # Shorten the line so it doesn't overlap the symbol

            source_size = ((float(self.nodes[source]['size']) * 5) / 2) * size
            target_size = ((float(self.nodes[target]['size']) * 5) / 2) * size

            edge_style = None

            # First set the edge style to the default of 'None', so if there isn't a connection type a line is still drawn
            for es in style['edges']:
                if es['label'] == None:
                    edge_style = es

            # Then go over the connections again and if there is a matching connection type, set that as the edge_style
            for es in style['edges']:
                for v in data.values():
                    if es['label'] == v:
                        edge_style = es
                        break

            if curved == False:
                if edge_style['stroke-case'] > 0:
                    if edge_style['stroke-dasharray'] is None:
                        edges_group.add(
                            dwg.line(start=start,
                                     end=end,
                                     stroke=edge_style['stroke-case-color'],
                                     stroke_width=edge_style['stroke-case']))
                    else:
                        edges_group.add(
                            dwg.line(
                                start=start,
                                end=end,
                                stroke=edge_style['stroke-case-color'],
                                stroke_width=edge_style['stroke-case'],
                                stroke_dasharray=edge_style['stroke-dasharray']
                            ))

                if edge_style['stroke-dasharray'] is None:
                    edges_group.add(
                        dwg.line(start=start,
                                 end=end,
                                 stroke=edge_style['stroke'],
                                 stroke_width=edge_style['stroke-width']))
                else:
                    edges_group.add(
                        dwg.line(
                            start=start,
                            end=end,
                            stroke=edge_style['stroke'],
                            stroke_width=edge_style['stroke-width'],
                            stroke_dasharray=edge_style['stroke-dasharray']))

                arrowhead_size = 5 * size

                offset = calculate_edge_offset(start, end, target_size)

                arrowhead_geom = arrowhead(start[0],
                                           start[1],
                                           offset[0],
                                           offset[1],
                                           r=arrowhead_size)

                if edge_style['stroke-case'] > 0:
                    fill = edge_style['stroke-case-color']
                else:
                    fill = edge_style['stroke']

                edges_group.add(dwg.polygon(arrowhead_geom, fill=fill))

            else:
                path = draw_curved_path(dwg, start, end, edge_style)
                if edge_style['stroke-case'] > 0:
                    edges_group.add(path[1])
                    edges_group.add(path[0])
                else:
                    edges_group.add(path)

                # Calculate arrowhead angle

                angle = angle_between_points(start, end)

                control_points = calculate_control_points(start, end)

                arrowhead_size = 5 * size

                crv = BSpline.Curve()

                crv.degree = 2

                if (start[0] > end[0]):
                    crv.ctrlpts = [start, control_points[0], end]
                else:
                    crv.ctrlpts = [start, control_points[1], end]

                crv.knotvector = utilities.generate_knot_vector(
                    crv.degree, len(crv.ctrlpts))

                crv.delta = 0.05

                curve_points = crv.evalpts

                l = LineString(curve_points)

                p = Point(end[0], end[1])
                c = p.buffer(target_size).boundary
                i = c.intersection(l)

                # If the nodes are too close together, i sometimes returns empty, therefore don't draw the arrowhead
                try:
                    if (start[0] > end[0]):
                        arrowhead_geom = arrowhead(control_points[0][0],
                                                   control_points[0][1],
                                                   i.coords[0][0],
                                                   i.coords[0][1],
                                                   r=arrowhead_size)
                    else:
                        arrowhead_geom = arrowhead(control_points[1][0],
                                                   control_points[1][1],
                                                   i.coords[0][0],
                                                   i.coords[0][1],
                                                   r=arrowhead_size)
                except:
                    pass

                #offset = calculate_edge_offset(start, end, target_size)

                #if (start[0] > end[0]):
                #    arrowhead_geom = arrowhead(control_points[0][0], control_points[0][1], offset[0], offset[1], r=arrowhead_size)
                #else:
                #    arrowhead_geom = arrowhead(control_points[1][0], control_points[1][1], offset[0], offset[1], r=arrowhead_size)

                if edge_style['stroke-case'] > 0:
                    fill = edge_style['stroke-case-color']
                else:
                    fill = edge_style['stroke']

                edges_group.add(dwg.polygon(arrowhead_geom, fill=fill))

        ## Now draw the nodes

        nodes_group = dwg.add(dwg.g())

        for node, data in self.nodes.items():
            x = data['x']
            y = data['y']
            node_size = (node_scale * (float(data['size']) * size),
                         node_scale * (float(data['size'])) * size)

            circle = nodes_group.add(
                dwg.circle(stroke='none',
                           fill=style['background']['color'],
                           center=(x, y),
                           r=node_size[0] / 2))

            # Get the symbology or colour scheme
            for node_style in style['nodes']:
                for v in data.values():
                    if node_style['label'] == v:
                        with open(node_style['symbol'], 'rb') as file:
                            img = file.read()
                            encoded = base64.b64encode(img).decode()
                            svgdata = 'data:image/svg+xml;base64,{}'.format(
                                encoded)
                            image = nodes_group.add(
                                dwg.image(href=svgdata,
                                          insert=(x - (node_size[0] / 2),
                                                  y - (node_size[0] / 2)),
                                          size=node_size))

        # Add the labels
        for node, data in self.nodes.items():
            x = data['x']
            y = data['y']
            node_size = (node_scale * (float(data['size']) * size),
                         node_scale * (float(data['size'])) * size)
            font_size = (node_size[0] * size) * label_correction
            label = nodes_group.add(
                dwg.text(text=node,
                         insert=(x, y + (node_size[0] * 0.2)),
                         font_size=font_size,
                         text_anchor='middle',
                         font_family=style['label']['font-family'],
                         fill=style['label']['fill']))

        dwg.save()
Exemple #24
0
    # # Draw the control points polygon, the 3D curve and the vectors
    # fig = plt.figure('figure X', figsize=(10.67, 8), dpi= 96)
    # ax = Axes3D(fig)

    for j in range(curve_geometry.NbPoles):
        data = model_part.GetNode(j + 1).X, model_part.GetNode(
            j + 1).Y, model_part.GetNode(j + 1).Z
        ctlpts_list.write(
            str(model_part.GetNode(j + 1).X) + ',' +
            str(model_part.GetNode(j + 1).Y) + ',' +
            str(model_part.GetNode(j + 1).Z) + '\n')

    ctlpts_list.close()
    plot_curve.ctrlpts = exchange.import_txt(
        "C:\_Masterarbeit\BeamValidation\python_base\Balken\ctlpts_list.txt")
    plot_curve.knotvector = utilities.generate_knot_vector(
        plot_curve.degree, len(plot_curve.ctrlpts))
    # Set evaluation delta
    # plot_curve.delta = 0.001
    # plot_curve.evaluate

    # add to mulit_curve
    multi_curve.add(plot_curve)

# Set evaluation delta
multi_curve.delta = 0.001
# multi_curve.evaluate
# plot the controlpoint polygon and the evaluated curve
vis_comp = VisMPL.VisCurve3D()
multi_curve.vis = vis_comp
multi_curve
multi_curve.render(cpcolor='black', evalcolor='red')
Exemple #25
0
       [274, 438], [193, 436], [150, 525], [204, 604]]
pts_c = [[204, 604], [284, 612], [387, 577], [485, 475], [430,
                                                          366], [325, 231],
         [274, 438], [193, 436], [150, 525], [204, 604], [284, 612],
         [387, 577]]
#pts = [[204, 604], [284, 612], [430, 366], [274, 438], [193, 436], [204, 604]]
#pts_c = [[204, 604], [284, 612], [430, 366], [274, 438], [193, 436], [204, 604], [284, 612], [430, 366]]
#radius = max([functions.euclid_dist(center, p) for p in pts])

curves_1 = []
curves_0 = []

curve.degree = 3  # order = degree + 1
curve.ctrlpts = pts_c
curve.knotvector = utilities.generate_knot_vector(curve.degree,
                                                  len(curve.ctrlpts),
                                                  clamped=False)
curve_list = operations.decompose_curve(curve)
knot_vectors = []
radius = 0

for c in curve_list:
    knot_vectors.append(c.knotvector)
    curves_0.append(c)
    radius = max(radius,
                 max([functions.euclid_dist(center, p) for p in c.ctrlpts]))

base_pts = [(p[0], p[1]) for c in curve_list for p in c.ctrlpts]
x, y, r = make_circle(base_pts)  # O(n)
center = (x, y)
radius = r