bei1111111

最新推荐文章于 2024-08-31 15:42:00 发布
最新推荐文章于 2024-08-31 15:42:00 发布
阅读量102 收藏
点赞数
分类专栏： 雷达 文章标签： 聚类 机器学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woohitler/article/details/123575412
版权 
import time
from math import sqrt

from sklearn.cluster import DBSCAN
from KF import KalmanFilter
import numpy as np
import open3d as o3d
from pynput import keyboard
import threading
from fuc.getPoints import *
from fuc.track import *

np.warnings.filterwarnings('ignore', category=np.VisibleDeprecationWarning)

k1 = -1.0787464
b1 = 164.38382
k2 = -0.97042704
b2 = 173.88885

kk1 = -0.5019615
bb1 = 159.25883
kk2 = -0.54667634
bb2 = 179.50114

xl = 0
xr = 0
sl = 0
sr = 0
xlShow = False
xrShow = False
srShow = False
slShow = False
leftc = 0
rightc = 0

p = 1


def get_length(ll, lr, l, r):
    # 左脚位置发生了变化
    # if (ll[0] - l[0]) * (ll[0] - l[0]) + (ll[1] - l[1]) * (ll[1] - l[1]) > 10000:
    #     print("左脚位置发生了变化", (ll[0] - l[0]) * (ll[0] - l[0]) + (ll[1] - l[1]) * (ll[1] - l[1]))
    if (lr[0] - r[0])*(lr[0] - r[0])+(lr[1] - r[1])*(lr[1] - r[1])>1000:
        print("右脚位置发生了变化",(lr[0] - r[0])*(lr[0] - r[0])+(lr[1] - r[1])*(lr[1] - r[1]))


def if_null():
    la = 0  # 浅蓝色脚质心
    ra = 0  # 蓝色脚质心
    global xl, xr, sl, sr, xlShow, xrShow, srShow, slShow, leftc, rightc
    if xl == 0:
        if xr == 1:
            if sr == 1:
                srShow = False
            if sl == 1:
                slShow = False
            leftc = 0
        if xr == 2:
            if sr == 2:
                srShow = False
            if sl == 2:
                slShow = False
            rightc = 0
    if xr == 0:
        if xl == 1:
            if sr == 1:
                srShow = False
            if sl == 1:
                slShow = False
            leftc = 0
        if xl == 2:
            if sr == 2:
                srShow = False
            if sl == 2:
                slShow = False
            rightc = 0
    if sl == 0:
        if sr == 1:
            if xr == 1:
                xrShow = False
            if xl == 1:
                xlShow = False
            rightc = 0
        if sr == 2:
            if xr == 2:
                xrShow = False
            if xl == 2:
                xlShow = False
            leftc = 0
    if sr == 0:
        if sl == 1:
            if xr == 1:
                xrShow = False
            if xl == 1:
                xlShow = False
            rightc = 0
        if sl == 2:
            if xr == 2:
                xrShow = False
            if xl == 2:
                xlShow = False
            leftc = 0

    return la, ra


def leftRight(pointList, s1, s2):
    # 点云聚类，从非地图点里区分人脚
    f0 = open(s1, "w+")
    f1 = open(s2, "w+")
    leftFootList = []
    rightFootList = []
    n = 0
    db = DBSCAN(eps=5, min_samples=7)
    db.fit(pointList)
    label = db.labels_
    for point in pointList:
        s = str(point[0]) + " " + str(point[1]) + " " + str(0) + "\n"
        if label[n] == 0:
            leftFootList.append(point)
            f0.write(s)
        if label[n] == 1:
            rightFootList.append(point)
            f1.write(s)
        n = n + 1


def remove_mapPoint(cloud):
    # 去除地图点云中的离群点
    cl, ind = cloud.remove_radius_outlier(nb_points=3, radius=6)
    inlier_source = cloud.select_by_index(ind)
    return inlier_source


def remove_point(cloud):
    # 去除脚步点云中的离群点
    cl, ind = cloud.remove_radius_outlier(nb_points=4, radius=20)
    inlier_source = cloud.select_by_index(ind)
    # print(inlier_source)
    return inlier_source


def fliter(mapTxt, footTxt, newFootTxt):
    # 地图点点云，脚步点点云，要写的点云文件
    # 分离包含脚步点云的点云中的脚步
    n = 0
    f0 = open(newFootTxt, "w+")
    fMap = open(mapTxt, "r")
    fFoot = open(footTxt, "r")
    mapLine = fMap.readlines()
    footLine = fFoot.readlines()
    sumLine = len(footLine)
    while n < sumLine:
        mapPoint = mapLine[n].split(' ')
        footPoint = footLine[n].split(' ')
        mapX = float(mapPoint[0])
        mapY = float(mapPoint[1])
        footX = float(footPoint[0])
        footY = float(footPoint[1])
        # 去除0,0点
        if footX == 0 and footY == 0:
            n = n + 1
            continue
        if ((mapX - footX) ** 2 + (mapY - footY) ** 2) >= 100:
            # 判断为脚步点
            s = footPoint[0] + " " + footPoint[1] + " " + str(0) + "\n"
            f0.write(s)
        n = n + 1


def disxLR(pcd):
    points = np.array(pcd.points)
    if points.shape[0] == 0:
        return 0
    [x, y, z] = np.mean(points, axis=0)
    d1 = round(abs(k1 * x - y + b1) / np.sqrt(k1 ** 2 + 1), 2)
    d2 = round(abs(k2 * x - y + b2) / np.sqrt(k2 ** 2 + 1), 2)

    if d1 < d2:
        return 1
    else:
        return 2


def dissLR(pcd):
    points = np.array(pcd.points)
    if points.shape[0] == 0:
        return 0
    [x, y, z] = np.mean(points, axis=0)
    d1 = round(abs(kk1 * x - y + bb1) / np.sqrt(kk1 ** 2 + 1), 2)
    d2 = round(abs(kk2 * x - y + bb2) / np.sqrt(kk2 ** 2 + 1), 2)

    if d1 < d2:
        return 1
    else:
        return 2


def on_press(key):
    global p
    try:
        if key.char == 'p':
            p = -p
    except AttributeError:
        print('special key {0} pressed'.format(key))


def run():
    while (True):
        with keyboard.Listener(on_press=on_press) as listener:
            listener.join()


if __name__ == "__main__":
    t = threading.Thread(target=run)
    t.setDaemon(True)
    t.start()
    # 旋转矩阵 ICP配准后获得
    tp = [[-0.97054084, 0.24093666, 0., 142.35725171],
          [-0.24093666, -0.97054084, 0., 232.05485009],
          [0., 0., 1., 0.],
          [0., 0., 0., 1.]]
    T = np.eye(4)
    ifChange = False
    iftxt = True
    n = 1
    s1 = '../data/smapp.txt'  # S雷达测得的地图
    s2 = '../data/sfoott.txt'  # S雷达测得的包含脚步的地图
    s3 = '../data/cloud1.txt'  # S雷达地图txt点云
    s4 = '../data/cloud2.txt'  # S雷达包含脚步的地图txt点云
    s5 = '../data/cloud3.txt'  # S雷达分离出的人脚txt点云
    x1 = '../data/xmapp.txt'  # X雷达同S
    x2 = '../data/xfoott.txt'
    x3 = '../data/xcloud1.txt'
    x4 = '../data/xcloud2.txt'
    x5 = '../data/xcloud3.txt'
    fc = open('../data/focusCloud.txt', 'w+')
    f0 = open('../data/dara.txt', 'w+')
    f1 = open('../data/data.txt', 'w+')
    # 以s雷达地图为基准 x雷达地图进行配准 获取选旋转矩阵后旋转x雷达中的脚步 画到s地图中
    get_mapPoints(s1, s3)
    get_mapPoints(x1, x3)
    vis = o3d.visualization.Visualizer()
    vis.create_window(window_name="脚步分离",
                      width=1700, height=900,
                      left=50, top=50)
    mapCloud = o3d.io.read_point_cloud(s3, format='xyz')
    focusCloud = o3d.io.read_point_cloud('../data/focusCloud.txt', format='xyz')
    mapCloud = remove_mapPoint(mapCloud)
    xleftFootCloud = o3d.io.read_point_cloud('../data/xleftFootCloud.txt', format='xyz')
    xrightFootCloud = o3d.io.read_point_cloud('../data/xrightFootCloud.txt', format='xyz')
    leftFootCloud = o3d.io.read_point_cloud('../data/leftFootCloud.txt', format='xyz')
    rightFootCloud = o3d.io.read_point_cloud('../data/rightFootCloud.txt', format='xyz')
    # mapCloud.paint_uniform_color([0, 1, 0])  # 点云着色
    newCloud = o3d.io.read_point_cloud('../data/xleftFootCloud.txt', format='xyz')
    xkfLeft = KalmanFilter.KalmanFilter()
    xkfRight = KalmanFilter.KalmanFilter()
    skfLeft = KalmanFilter.KalmanFilter()
    skfRight = KalmanFilter.KalmanFilter()
    # 初始化
    xkfLeft.initModel()
    xkfRight.initModel()
    skfLeft.initModel()
    skfRight.initModel()
    # 动态展示
    llav = [0, 0]
    lrav = [0, 0]
    nL = 0
    while True:
        nL = nL + 1
        # 左右脚重心
        leftAv = [0, 0]
        rightAv = [0, 0]
        if p == -1:
            vis.run()
            while (True):
                print(p)
                if p == 1:
                    vis.destroy_window()
                    vis = o3d.visualization.Visualizer()
                    vis.create_window(window_name="脚步分离",
                                      width=1700, height=900,
                                      left=50, top=50)
                    break
        slShow = True
        srShow = True
        xlShow = True
        xrShow = True
        leftc = 0
        rightc = 0
        change = False
        vis.remove_geometry(focusCloud)
        vis.remove_geometry(mapCloud)
        vis.remove_geometry(newCloud)
        vis.remove_geometry(xleftFootCloud)
        vis.remove_geometry(xrightFootCloud)
        vis.remove_geometry(leftFootCloud)
        vis.remove_geometry(rightFootCloud)
        newCloud = o3d.io.read_point_cloud('../data/smappoints.txt', format='xyz')
        focusCloud = o3d.io.read_point_cloud('../data/focusCloud.txt', format='xyz')
        focusCloud.paint_uniform_color([0, 1, 0])
        fla = get_footPoints(s2, s4, n)
        if fla == 1:
            break
        fla = get_footPoints(x2, x4, n)
        if fla == 1:
            break
        fliter(s3, s4, s5)
        fliter(x3, x4, x5)

        footCloud = o3d.io.read_point_cloud(s5, format='xyz')
        xfootCloud = o3d.io.read_point_cloud(x5, format='xyz')
        footArray = np.array(footCloud.points)
        xfootArray = np.array(xfootCloud.points)

        leftRight(footArray, '../data/leftFootCloud.txt', '../data/rightFootCloud.txt')
        leftRight(xfootArray, '../data/xleftFootCloud.txt', '../data/xrightFootCloud.txt')

        leftFootCloud = o3d.io.read_point_cloud('../data/leftFootCloud.txt', format='xyz')
        rightFootCloud = o3d.io.read_point_cloud('../data/rightFootCloud.txt', format='xyz')
        xleftFootCloud = o3d.io.read_point_cloud('../data/xleftFootCloud.txt', format='xyz')
        xrightFootCloud = o3d.io.read_point_cloud('../data/xrightFootCloud.txt', format='xyz')

        # 区分左右脚，并修正卡尔曼滤波--------------------------------------------------------
        xl = disxLR(xleftFootCloud)
        xr = disxLR(xrightFootCloud)
        xleftFootCloud.transform(tp)
        xrightFootCloud.transform(tp)
        # 1:right
        # 2:left
        if xl == 1:
            rightc = rightc + np.array(xleftFootCloud.points).shape[0]
            xleftFootCloud.paint_uniform_color([0, 0, 1])
            xkfRight.predict()
            xkfRight.correct(np.mean(np.array(xleftFootCloud.points)[:, :2], axis=0).reshape(2, 1))
            rightAv = np.mean(np.array(xleftFootCloud.points)[:, :2], axis=0)
        if xl == 2:
            leftc = leftc + np.array(xleftFootCloud.points).shape[0]
            xleftFootCloud.paint_uniform_color([0, 1, 1])
            xkfLeft.predict()
            xkfLeft.correct(np.mean(np.array(xleftFootCloud.points)[:, :2], axis=0).reshape(2, 1))
            leftAv = np.mean(np.array(xleftFootCloud.points)[:, :2], axis=0)
        if xr == 1:
            rightc = rightc + np.array(xrightFootCloud.points).shape[0]
            xrightFootCloud.paint_uniform_color([0, 0, 1])
            xkfRight.predict()
            xkfRight.correct(np.mean(np.array(xrightFootCloud.points)[:, :2], axis=0).reshape(2, 1))
            rightAv = np.mean(np.array(xrightFootCloud.points)[:, :2], axis=0)
        if xr == 2:
            leftc = leftc + np.array(xrightFootCloud.points).shape[0]
            xrightFootCloud.paint_uniform_color([0, 1, 1])
            xkfLeft.predict()
            xkfLeft.correct(np.mean(np.array(xrightFootCloud.points)[:, :2], axis=0).reshape(2, 1))
            leftAv = np.mean(np.array(xrightFootCloud.points)[:, :2], axis=0)

        sl = dissLR(leftFootCloud)
        sr = dissLR(rightFootCloud)
        # 1:left
        # 2:right
        if sl == 1:
            leftc = leftc + np.array(leftFootCloud.points).shape[0]
            leftFootCloud.paint_uniform_color([0, 1, 1])
            skfLeft.predict()
            skfLeft.correct(np.mean(np.array(leftFootCloud.points)[:, :2], axis=0).reshape(2, 1))
            leftAv = (leftAv + np.mean(np.array(leftFootCloud.points)[:, :2], axis=0)) / 2
        if sl == 2:
            rightc = rightc + np.array(leftFootCloud.points).shape[0]
            leftFootCloud.paint_uniform_color([0, 0, 1])
            skfRight.predict()
            skfRight.correct(np.mean(np.array(leftFootCloud.points)[:, :2], axis=0).reshape(2, 1))
            rightAv = (rightAv + np.mean(np.array(leftFootCloud.points)[:, :2], axis=0)) / 2
        if sr == 1:
            leftc = leftc + np.array(rightFootCloud.points).shape[0]
            rightFootCloud.paint_uniform_color([0, 1, 1])
            skfLeft.predict()
            skfLeft.correct(np.mean(np.array(rightFootCloud.points)[:, :2], axis=0).reshape(2, 1))
            leftAv = (leftAv + np.mean(np.array(rightFootCloud.points)[:, :2], axis=0)) / 2
        if sr == 2:
            rightc = rightc + np.array(rightFootCloud.points).shape[0]
            rightFootCloud.paint_uniform_color([0, 0, 1])
            skfRight.predict()
            skfRight.correct(np.mean(np.array(rightFootCloud.points)[:, :2], axis=0).reshape(2, 1))
            rightAv = (rightAv + np.mean(np.array(rightFootCloud.points)[:, :2], axis=0)) / 2
        # -----------------------------------------------------------
        # 有缺失的情况
        # x雷达left丢了
        if (xl == 0 and xr == 1) or (xr == 0 and xl == 1):
            if sr == 1:
                xkfLeft.predict()
                txl = xkfLeft.correct(np.mean(np.array(rightFootCloud.points)[:, :2], axis=0).reshape(2, 1))
                rmean = np.mean(np.array(rightFootCloud.points)[:, :2], axis=0).reshape(2, 1)
                t = [txl[0] - rmean[0], txl[2] - rmean[1], 0]
                T[:3, 3] = t
                newCloud = copy.deepcopy(rightFootCloud).transform(T)
            if sl == 1:
                xkfLeft.predict()
                txl = xkfLeft.correct(np.mean(np.array(leftFootCloud.points)[:, :2], axis=0).reshape(2, 1))
                lmean = np.mean(np.array(leftFootCloud.points)[:, :2], axis=0).reshape(2, 1)
                t = [txl[0] - lmean[0], txl[2] - lmean[1], 0]
                T[:3, 3] = t
                newCloud = copy.deepcopy(leftFootCloud).transform(T)
        # x雷达right丢了
        if (xl == 0 and xr == 2) or (xr == 0 and xl == 2):
            if sr == 2:
                xkfRight.predict()
                txr = xkfRight.correct(np.mean(np.array(rightFootCloud.points)[:, :2], axis=0).reshape(2, 1))
                rmean = np.mean(np.array(rightFootCloud.points)[:, :2], axis=0).reshape(2, 1)
                t = [txr[0] - rmean[0], txr[2] - rmean[1], 0]
                T[:3, 3] = t
                newCloud = copy.deepcopy(rightFootCloud).transform(T)
            if sl == 2:
                xkfRight.predict()
                txr = xkfRight.correct(np.mean(np.array(leftFootCloud.points)[:, :2], axis=0).reshape(2, 1))
                lmean = np.mean(np.array(leftFootCloud.points)[:, :2], axis=0).reshape(2, 1)
                t = [txr[0] - lmean[0], txr[2] - lmean[1], 0]
                T[:3, 3] = t
                newCloud = copy.deepcopy(leftFootCloud).transform(T)
        # s雷达left丢了
        if (sl == 0 and sr == 2) or (sr == 0 and sl == 2):
            if xl == 2:
                skfLeft.predict()
                tsl = skfLeft.correct(np.mean(np.array(xleftFootCloud.points)[:, :2], axis=0).reshape(2, 1))
                xlmean = np.mean(np.array(xleftFootCloud.points)[:, :2], axis=0).reshape(2, 1)
                t = [tsl[0] - xlmean[0], tsl[2] - xlmean[1], 0]
                T[:3, 3] = t
                newCloud = copy.deepcopy(xleftFootCloud).transform(T)
            if xr == 2:
                skfLeft.predict()
                tsl = skfLeft.correct(np.mean(np.array(xrightFootCloud.points)[:, :2], axis=0).reshape(2, 1))
                xrmean = np.mean(np.array(xrightFootCloud.points)[:, :2], axis=0).reshape(2, 1)
                t = [tsl[0] - xrmean[0], tsl[2] - xrmean[1], 0]
                T[:3, 3] = t
                newCloud = copy.deepcopy(xrightFootCloud).transform(T)
        # s雷达right丢了
        if (sl == 0 and sr == 1) or (sr == 0 and sl == 1):
            if xl == 1:
                skfRight.predict()
                tsr = skfRight.correct(np.mean(np.array(xleftFootCloud.points)[:, :2], axis=0).reshape(2, 1))
                xlmean = np.mean(np.array(xleftFootCloud.points)[:, :2], axis=0).reshape(2, 1)
                t = [tsr[0] - xlmean[0], tsr[2] - xlmean[1], 0]
                T[:3, 3] = t
                newCloud = copy.deepcopy(xleftFootCloud).transform(T)
            if xr == 1:
                skfRight.predict()
                tsr = skfRight.correct(np.mean(np.array(xrightFootCloud.points)[:, :2], axis=0).reshape(2, 1))
                xrmean = np.mean(np.array(xrightFootCloud.points)[:, :2], axis=0).reshape(2, 1)
                t = [tsr[0] - xrmean[0], tsr[2] - xrmean[1], 0]
                T[:3, 3] = t
                newCloud = copy.deepcopy(xrightFootCloud).transform(T)
        # 过滤小点
        if_null()

        # 计算特征
        if leftAv[0] != 0 and rightAv[0] != 0:
            focus = (leftAv + rightAv) / 2
        elif leftAv[0] == 0:
            focus = rightAv
        else:
            focus = leftAv
        s = str(focus[0]) + " " + str(focus[1]) + " " + str(1) + "\n"
        fc.write(s)
        # print("the center of feet:", leftAv, rightAv)
        # print("the focus:", focus)
        # print("-----------------------------------------------------")
        # if nL == 4:
        #     if leftAv[0] == 0:
        #         llav = llav
        #     if rightAv[0] == 0:
        #         lrav = lrav
        #     else:
        #         get_length(llav, lrav, leftAv, rightAv)
        #         llav = leftAv
        #         lrav = rightAv
        #     nL = 0

        newCloud.paint_uniform_color([1, 0, 0])
        f0.write(str(leftc))
        f0.write('\n')
        f1.write(str(rightc))
        f1.write('\n')
        get_length(llav, lrav, leftAv, rightAv)
        # print(xlShow)
        if xlShow and slShow:
            # 有左脚)
            vis.add_geometry(xleftFootCloud)
            vis.add_geometry(leftFootCloud)
            llav = leftAv



        if xrShow and srShow:
            # 有右脚
            vis.add_geometry(xrightFootCloud)
            vis.add_geometry(rightFootCloud)
            lrav = rightAv
        else:
            print(11111)




        # vis.add_geometry(newCloud)
        vis.add_geometry(focusCloud)
        vis.add_geometry(mapCloud)
        vis.poll_events()  # 注册更新操作
        vis.update_renderer()  # 渲染图窗
        n = n + 1
        iftxt = True

    vis.destroy_window()  # 关闭显示窗口
WangShenJ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Go语言文件I/O操作
Gavin
05-24 941
在go中使用 FileInfo接口 定义了IO的一些函数。 ReadLine()通过调用ReadSlice()方法实现，返回的也是缓存的切片。ReadLine()尝试返回一个单行数据，不包括行尾标记（\n或\r\n），如果在缓存中找不到行尾标记，则设置isPrefix为true，表示查找未完成，同时读出缓存中的数据并作为切片返回；只有在当前缓存中找到行尾标记，才将isPrefix设置为false，表示查找完成。可以多次调用ReadLine()来读出一行，返回的数据在下一次读取操作之前是有效的。如果ReadL
【2024美赛】全面助力2024年美国大学生数学建模竞赛，祝大家取得好成绩
Fanjufei的博客
11-05 2万+
下面是翻译成中文的网页：（值得大学生去参加）2、2024年美赛摘要页说明（1）使用此模板开始键入电子报告的第一页（摘要页）。此模板使用12点Times New Roman字体。以Adobe PDF电子文件（如1111111.PDF）的形式提交论文，用英文打字，字体至少为12点可读。（2）不要在本页或任何一页上写上你的学校、导师或团队成员的名字。（3）论文必须在问题陈述中指定的页数限制内。（4）请务必更改上面的控制编号和问题选择。（5）开始在此处键入报表时，可以删除这些说明。
i.MX6Q -- Linux系统下FlexCAN总线的使用记录
qingma8132的博客
09-26 2199
开发板平台：珠海鼎芯D338 – 基于i.MX6Q 系统平台：Linux3.0.35 + Busybox1.221、 需要的工具 FlexCAN工具包： libsocketcan-0.0.10.tar.bz2 canutils-4.0.6.tar.bz2 交叉编译器： fsl-linaro-toolchain.tar.bz2
美赛备赛资料大全
热门推荐
May the Force be with you
01-26 4万+
目录 1、美赛比赛网址及其介绍 2、美赛摘要页说明 3、美赛常用词语与语句 4、美赛翻译注意事项 5、美赛论文写作一些建议 5.1 团队方面准备 5.2 摘要表部分 5.3 评委关注点 6、组队要求 7、软件与一些建模网址参考 （1）写一篇建模文章大致需要如下技能： （2）数学建模算法总结 （3） word小白教程 数据资料： （4）1982—2018中国统计年鉴大全链接 （5）美国人口普查数据大全链接 （6）美国城市数据大全链接 （7）全球统计数...
C++生成条型码和二维码源码及调用示例 还是C#方便
chenhao0568的专栏
12-19 3371
先画条型码会影响二维码，生成的没问题，粘到主图有问题，改成::SetStretchBltMode(memDC, COLORONCOLOR);后正常，不论先后顺序。先画二维码正常，正常情况下也不重叠。C++处理二维码: 字符串--二维码比特矩阵--保存二维码图片--粘到主图中。先看调用，越简单越好。
C语言文件操作 文件已经存在则清空，不存在则新建文件 生成二维码图片
chenhao0568的专栏
08-26 1366
文件已经存在则清空，不存在则新建文件。
CF Educational Codeforces Round 15（A~D）
hkh746392783的专栏
07-30 686
题目链接：http://codeforces.com/contest/702 A. Maximum Increase time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output You are
CAPTCHA zju 校赛 acm
Rachel Zhang的专栏
04-10 4667
CAPTCHATime Limit: 1 Second      Memory Limit: 32768 KB A CAPTCHA (Completely Automated Public Turing Test to Tell Computers and Humans Apart) is a program that generates and grades tests that
iOS进阶之atomic一定是线程安全的吗（10）
沐雨07的专栏
09-06 5419
IOS项目中nonatomic和atomic分析 //有两个属性，分别设置为nonatomic和atomic #import <UIKit/UIKit.h> @interface ViewController : UIViewController @property (nonatomic, strong) NSString *name; @property (atomic, ass...
tuxedo编译后台报错常见问题
测试
12-15 384
1111111
STM32开发 -- CAN总线详解
不积跬步，无以至千里
11-11 9790
最近好像没在状态，博客也没有心思写了。 ADC花了好久好久才总结完了，现在就开始看一下CAN总线吧。 这部分我比较熟悉一些。
JSONP跨域资源共享的安全问题
谢公子的博客
02-14 6169
目录 关于 JSONP 一、JSON 劫持 二、Callback 可定义导致的安全问题 三、其他文件格式（ Content-Type ）与 JSON 四、防御 摘自：http://blog.knownsec.com/2015/03/jsonp_security_technic/ 关于 JSONP JSONP跨域 安全问题一直都是伴随着业务发展而出现的，JSONP 的出现同样带来了...
Apktool回编时Invalid register. Must be between v0 and v15, inclusive..的解决办法
随笔日志
12-22 9198
一般我们在自定义修改apk时，难免会对smali代码进行增减删改，再回编的时候可能会遇到如下错误： Invalid register: vx. Must be between v0 and v15, inclusive.其中vx>15，导致回编译错误。 错误原因可能有以下几种情况： 1.引用了不存在的方法参数。 参数个数很容易识别，但是一定要注意传入的方法参数是从p0,还是从p1开始的。根
《机器学习》K-means 聚类 原理、参数解析、案例实现
wx_AHao1004Y的博客
08-28 1847
K-means是一种常用的无监督学习算法，用于将数据集中的对象划分为k个不同的组或簇。该算法的目标是最小化每个数据点与所属簇的质心之间的平方欧氏距离之和。
机器学习 之 DBSCAN算法 及实现
m0_73697499的博客
08-28 1317
通过上述步骤，我们完成了 DBSCAN 聚类分析的过程。灵活性：DBSCAN 不需要预先知道簇的数量。噪声处理：DBSCAN 能够有效地识别和排除噪声点。任意形状簇：DBSCAN 能够发现任意形状的簇。在本实验中，我们不仅实现了 DBSCAN 算法，还通过轮廓系数得分来评估聚类结果的质量。DBSCAN 的这些特性使其在处理复杂数据集时特别有用，尤其是在需要识别噪声和发现不规则簇形状的情况下。
【机器学习】.fit_transform()跟.transform()的区别
最新发布
2301_81133727的博客
08-31 433
在您的输出中，训练数据和测试数据的编码结果可能看起来不一致，这是因为训练数据中的类别和测试数据中的类别不完全匹配。然而，您的输出结果似乎假设了训练数据和测试数据中有相同的类别，这在实际情况中可能不是真的。默认将每个特征的每个唯一值转换成一个二进制特征，其中1表示该类别存在，0表示不存在。对于测试数据，我们有两个样本，每个样本有两个特征是1。，所以在第二个和第五个特征上是1，其余是0。参数，这样对于未知的类别，编码器会输出全0。，所以第一个和第四个特征是1，其余是0。用于训练数据来学习类别并转换它们，而。
机器学习（ML）算法分类
m0_46171719的博客
08-28 203
机器学习算法种类繁多，每种算法都有其独特的优势和适用场景。在选择算法时，需要根据具体问题的性质、数据的特征以及预期的结果来综合考虑。同时，随着机器学习技术的不断发展，新的算法和模型不断涌现，为解决复杂问题提供了更多的可能性。机器学习（ML）算法是一个广泛而多样的领域，涵盖了多种用于数据分析和模式识别的技术。监督学习算法使用标记（即已知结果）的训练数据来训练模型，以便对新数据进行预测。无监督学习算法不需要标记的训练数据，而是从数据中自动发现隐藏的模式或结构。
朴素贝叶斯分类算法
m0_73676887的博客
08-28 942
P特征∣类别×P类别P类别P特征∣类别。
开尔文函数 matlab，计算ber，bei
06-07
好的，对于计算开尔文函数的ber和bei，Matlab中有内置的函数可供调用。具体来说，Matlab中的开尔文函数为kelvin。 kelvin函数有两个输入参数，第一个是整数n，表示需要计算的开尔文函数的类型，第二个是实数x，表示...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值