mv:调参，阈值

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量139 收藏
点赞数 1
分类专栏： mv 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lmf666/article/details/141052575
版权 
import sensor, image, time
from pyb import LED,Pin
from pyb import Timer
import lcd









task_mode = 0  #0:初始模式，就是录像，1：调参模式
blue_led = LED(1)


thresholds = [
    (15, 25, 10, 25, -5, 20),  # generic_red_thresholds(15, 23, 10, 24, 0, 18)
    (30, 100, -64, -8, -32, 32),  # generic_green_thresholds
    (0, 15, 0, 40, -80, -20),
]  # generic_blue_thresholds

g_thread_red   =[15, 25, 10, 25, -5, 20]
g_thread_green =[30, 100, -64, -8, -32, 32]
g_thread_blue  =[0, 15, 0, 40, -80, -20]

sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.VGA)

sensor.set_windowing(320,320)

sensor.set_auto_whitebal(False)

#gain_par =0.8
#sensor.set_auto_gain(False, gain_db_ceiling=gain_par)  # Default gain 10.

sensor.set_auto_gain(False)  # Default gain 10.

EXPOSURE_MICROSECONDS = 100000
#sensor.set_auto_exposure(False, exposure_us=EXPOSURE_MICROSECONDS)
sensor.set_auto_exposure(True, exposure_us=EXPOSURE_MICROSECONDS)

try:
    # The camera will now focus on whatever is in front of it.
    sensor.ioctl(sensor.IOCTL_TRIGGER_AUTO_FOCUS)
except:
    raise (Exception("Auto focus is not supported by your sensor/board combination."))

sensor.skip_frames(time = 200)
clock = time.clock()
lcd.init(1, 128, height=160, framesize=0, refresh=30, triple_buffer=False, bgr=False)


#lcd_img =img.scale(0.4,0.5)
#lcd_img.draw_string(0,0,"par_index: %d "% ((par_index)))
#lcd.display(lcd_img)

#blue_led = LED(1)
KEY = Pin('C13',Pin.IN,Pin.PULL_DOWN)
KEY1 = Pin('A0',Pin.IN,Pin.PULL_UP)
KEY2 = Pin('A2',Pin.IN,Pin.PULL_UP)
KEY3 = Pin('A5',Pin.IN,Pin.PULL_UP)#A4A6 不行
KEY4 = Pin('A7',Pin.IN,Pin.PULL_UP)
KEY5 = Pin('C4',Pin.IN,Pin.PULL_UP)
KEY6 = Pin('B0',Pin.IN,Pin.PULL_UP)

print("You're on camera!")
keycount=0
# 轻触开关

waitkeyflag=0
keyval=0
#等开关按下并松开
def wait_key():
    global keyval,waitkeyflag
    while KEY.value():

        while KEY.value():
            while KEY.value(): #wait key up
                i=0   #anything you like
                print("here01")
            keyval=100
            waitkeyflag=1

key1_status=0
key2_status=0
key3_status=0
key4_status=0
key5_status=0
key6_status=0

key_val =0
key_testnum=0;
key1_step =0
par_index =0

#file_abs = "save1.txt"
f =open("save1.txt","r",encoding = "unicode")
content=""
try :
    while(True):
        chunk = f.read().strip('\x00') #读取文件
        print(chunk)
        if not chunk:
           break
        content =chunk
finally:
    f.seek(0)
    f.close()  #关闭文件
print("content=")
print(content)
print(type(content))
readnum = content.split(",")
print("readnum=")
print(readnum)
print(type(readnum))
print("readnum0=")
print(readnum[0])
print(type(readnum[0]))
g_thread_red[0]=int(readnum[0])
g_thread_red[1]=int(readnum[1])
g_thread_red[2]=int(readnum[2])
g_thread_red[3]=int(readnum[3])
g_thread_red[4]=int(readnum[4])
g_thread_red[5]=int(readnum[5])

g_thread_green[0]=int(readnum[6])
g_thread_green[1]=int(readnum[7])
g_thread_green[2]=int(readnum[8])
g_thread_green[3]=int(readnum[9])
g_thread_green[4]=int(readnum[10])
g_thread_green[5]=int(readnum[11])

g_thread_blue[0]=int(readnum[12])
g_thread_blue[1]=int(readnum[13])
g_thread_blue[2]=int(readnum[14])
g_thread_blue[3]=int(readnum[15])
g_thread_blue[4]=int(readnum[16])
g_thread_blue[5]=int(readnum[17])


print("-@@red--start")
print(g_thread_red[0])
print(g_thread_red[1])
print(g_thread_red[2])
print(g_thread_red[3])
print(g_thread_red[4])
print(g_thread_red[5])
print("-@@red--end")

timer4cnt =0
def tick(timer):            # we will receive the timer object when being called
    global timer4cnt
    timer4cnt+=1
#    print("t400")
    if timer4cnt==2:
        timer4cnt =0
        KEY1_Read()
        KEY2_Read()
        KEY3_Read()
        KEY4_Read()
        KEY5_Read()
        KEY6_Read()
#f =open(file_abs,"w")
tim = Timer(4, freq=20)      # create a timer object using timer 4 - trigger at 5Hz
tim.callback(tick)          # set the callback to our tick function

def KEY1_Read():
    global key1_status
    global waitkeyflag
    global task_mode,key1_step
    global par_index
#    print("key1_read........")
    if KEY1.value()==0 and key1_status==1 and key1_step==0:#2.按键被按下的瞬间，下降沿
        task_mode =1  #调到调参模式
        key1_step =1
        print("h01333333333333333333")

    if KEY1.value()==0 and key1_status==1 and key1_step==1:#2.按键被按下的瞬间，下降沿
        #waitkeyflag =1
        print("task_mode=",task_mode)
        if task_mode==1: #如果是调参模式
            par_index +=1
            if par_index==18:#参数0-17之间,0-5红色，6-11绿，12-17蓝
                par_index=0
            print("par_index=",par_index)
#        print("h08888888888888888")
    elif KEY1.value()==0 and key1_status==0 and key1_step==1 :#3.按键被按下的状态，
        #用户自定义函数
        clock.tick()
        #print("u01444444444444444444")

    key1_status=KEY1.value()	#获取最新状态

def KEY2_Read():
    global key2_status
    global g_thread_red,g_thread_green,g_thread_blue
    global par_index

    if KEY2.value()==0 and key2_status==1 :#2.按键被按下的瞬间，下降沿
        #用户自定义函数
#        print("key2 is up to down")
        if 0<=par_index<6:

            g_thread_red[par_index] +=5
            if g_thread_red[0]>=100:g_thread_red[0] =0
            if g_thread_red[1]>=100:g_thread_red[1] =0
            if g_thread_red[2]>=128:g_thread_red[2] =-127
            if g_thread_red[3]>=128:g_thread_red[3] =-127
            if g_thread_red[4]>=128:g_thread_red[4] =-127
            if g_thread_red[5]>=128:g_thread_red[5] =-127

            print("KEY2 g_thread_red[par_index]=",g_thread_red[par_index])

        elif 6<=par_index<12:
            g_thread_green[par_index-6] +=5
            if g_thread_green[0]>=100:g_thread_green[0] =0
            if g_thread_green[1]>=100:g_thread_green[1] =0
            if g_thread_green[2]>=128:g_thread_green[2] =-127
            if g_thread_green[3]>=128:g_thread_green[3] =-127
            if g_thread_green[4]>=128:g_thread_green[4] =-127
            if g_thread_green[5]>=128:g_thread_green[5] =-127






            print('KEY2 g_thread_green[par_index]=',g_thread_green[par_index-6])
#            print("key2000..")
        elif 12<=par_index<18:
            g_thread_blue[par_index-12] +=5
            if g_thread_blue[0]>=100:g_thread_blue[0] =0
            if g_thread_blue[1]>=100:g_thread_blue[1] =0
            if g_thread_blue[2]>=128:g_thread_blue[2] =-127
            if g_thread_blue[3]>=128:g_thread_blue[3] =-127
            if g_thread_blue[4]>=128:g_thread_blue[4] =-127
            if g_thread_blue[5]>=128:g_thread_blue[5] =-127

            print("KEY2 g_thread_blue[par_index]=",g_thread_blue[par_index-12])
#            print("key2111..")
    elif KEY2.value()==0 and key2_status==0 :#3.按键被按下的状态，
       #用户自定义函数
#        print("key2 is downing")
        if 0<=par_index<6:
           g_thread_red[par_index] +=5
           if g_thread_red[0]>=100:g_thread_red[0] =0
           if g_thread_red[1]>=100:g_thread_red[1] =0
           if g_thread_red[2]>=128:g_thread_red[2] =-127
           if g_thread_red[3]>=128:g_thread_red[3] =-127
           if g_thread_red[4]>=128:g_thread_red[4] =-127
           if g_thread_red[5]>=128:g_thread_red[5] =-127
           print("KEY2 g_thread_red[par_index]=",g_thread_red[par_index])

        elif 6<=par_index<12:
            g_thread_green[par_index-6] +=5
            if g_thread_green[0]>=100:g_thread_green[0] =0
            if g_thread_green[1]>=100:g_thread_green[1] =0
            if g_thread_green[2]>=128:g_thread_green[2] =-127
            if g_thread_green[3]>=128:g_thread_green[3] =-127
            if g_thread_green[4]>=128:g_thread_green[4] =-127
            if g_thread_green[5]>=128:g_thread_green[5] =-127
            print('KEY2 g_thread_green[par_index]=',g_thread_green[par_index-6])
#            print("key2000..")
        elif 12<=par_index<18:
            g_thread_blue[par_index-12] +=5
            if g_thread_blue[0]>=100:g_thread_blue[0] =0
            if g_thread_blue[1]>=100:g_thread_blue[1] =0
            if g_thread_blue[2]>=128:g_thread_blue[2] =-127
            if g_thread_blue[3]>=128:g_thread_blue[3] =-127
            if g_thread_blue[4]>=128:g_thread_blue[4] =-127
            if g_thread_blue[5]>=128:g_thread_blue[5] =-127
            print("KEY2 g_thread_blue[par_index]=",g_thread_blue[par_index-12])
#            print("key2111..")
    key2_status=KEY2.value()	#获取最新状态

def KEY3_Read():
    global key3_status
    global waitkeyflag
    global thresholds
    global par_index

    if KEY3.value()==0 and key3_status==1 :#2.按键被按下的瞬间，下降沿
        #用户自定义函数
        if 0<=par_index<6:
           g_thread_red[par_index] -=5
           if g_thread_red[0]<=0:g_thread_red[0] =100
           if g_thread_red[1]<=0:g_thread_red[1] =100
           if g_thread_red[2]<=-127:g_thread_red[2] =128
           if g_thread_red[3]<=-127:g_thread_red[3] =128
           if g_thread_red[4]<=-127:g_thread_red[4] =128
           if g_thread_red[5]<=-127:g_thread_red[5] =128
           print("KEY3 g_thread_red[par_index]=",g_thread_red[par_index])

        elif 6<=par_index<12:
            g_thread_green[par_index-6] -=5
            if g_thread_green[0]<=0:g_thread_green[0] =100
            if g_thread_green[1]<=0:g_thread_green[1] =100
            if g_thread_green[2]<=-127:g_thread_green[2] =128
            if g_thread_green[3]<=-127:g_thread_green[3] =128
            if g_thread_green[4]<=-127:g_thread_green[4] =128
            if g_thread_green[5]<=-127:g_thread_green[5] =128
            print('KEY3 g_thread_green[par_index]=',g_thread_green[par_index-6])
#            print("key2000..")
        elif 12<=par_index<18:
            g_thread_blue[par_index-12] -=5
            if g_thread_blue[0]<=0:g_thread_blue[0] =100
            if g_thread_blue[1]<=0:g_thread_blue[1] =100
            if g_thread_blue[2]<=-127:g_thread_blue[2] =128
            if g_thread_blue[3]<=-127:g_thread_blue[3] =128
            if g_thread_blue[4]<=-127:g_thread_blue[4] =128
            if g_thread_blue[5]<=-127:g_thread_blue[5] =128
            print("KEY3 g_thread_blue[par_index]=",g_thread_blue[par_index-12])
#            print("key2111..")

#        print("key3 is up to down")

    elif KEY3.value()==0 and key3_status==0 :#3.按键被按下的状态，
       #用户自定义函数
       #用户自定义函数
       if 0<=par_index<6:
          g_thread_red[par_index] -=5
          if g_thread_red[0]<=0:g_thread_red[0] =100
          if g_thread_red[1]<=0:g_thread_red[1] =100
          if g_thread_red[2]<=-127:g_thread_red[2] =128
          if g_thread_red[3]<=-127:g_thread_red[3] =128
          if g_thread_red[4]<=-127:g_thread_red[4] =128
          if g_thread_red[5]<=-127:g_thread_red[5] =128
          print("KEY3 g_thread_red[par_index]=",g_thread_red[par_index])

       elif 6<=par_index<12:
           g_thread_green[par_index-6] -=5
           if g_thread_green[0]<=0:g_thread_green[0] =100
           if g_thread_green[1]<=0:g_thread_green[1] =100
           if g_thread_green[2]<=-127:g_thread_green[2] =128
           if g_thread_green[3]<=-127:g_thread_green[3] =128
           if g_thread_green[4]<=-127:g_thread_green[4] =128
           if g_thread_green[5]<=-127:g_thread_green[5] =128
           print('KEY3 g_thread_green[par_index]=',g_thread_green[par_index-6])
#           print("key2000..")
       elif 12<=par_index<18:
           g_thread_blue[par_index-12] -=5
           if g_thread_blue[0]<=0:g_thread_blue[0] =100
           if g_thread_blue[1]<=0:g_thread_blue[1] =100
           if g_thread_blue[2]<=-127:g_thread_blue[2] =128
           if g_thread_blue[3]<=-127:g_thread_blue[3] =128
           if g_thread_blue[4]<=-127:g_thread_blue[4] =128
           if g_thread_blue[5]<=-127:g_thread_blue[5] =128
           print("KEY3 g_thread_blue[par_index]=",g_thread_blue[par_index-12])
#           print("key2111..")

    key3_status=KEY3.value()	#获取最新状态

key4val=0
def KEY4_Read():
    global key4_status
    global waitkeyflag
    global key4val
#    file_abs = "save.txt"
    if KEY4.value()==0 and key4_status==1 :#2.按键被按下的瞬间，下降沿
        #用户自定义函数
        key4val=1
        #关闭定时器，不然中断会有影响
        print("key4 is up to down")
    elif KEY4.value()==0 and key4_status==0 :#3.按键被按下的状态，
       #用户自定义函数
       clock.tick()
#       print("key4 is downing")
    key4_status=KEY4.value()	#获取最新状态

def KEY5_Read():
    global key5_status
    global task_mode,par_index
    if KEY5.value()==0 and key5_status==1 :#2.按键被按下的瞬间，下降沿
        #用户自定义函数
        if task_mode==1: #如果是调参模式
            par_index -=1
            if par_index==0:#参数0-17之间,0-5红色，6-11绿，12-17蓝
                par_index=17
            print("par_index=",par_index)
#        print("key5 is up to down")

    elif KEY5.value()==0 and key5_status==0 :#3.按键被按下的状态，
       #用户自定义函数
       clock.tick()
#       print("key5 is downing")
    key5_status=KEY5.value()	#获取最新状态

def KEY6_Read():
    global key6_status
    global waitkeyflag
    if KEY6.value()==0 and key6_status==1 :#2.按键被按下的瞬间，下降沿
        #用户自定义函数
        print("key6 is up to down")

    elif KEY6.value()==0 and key6_status==0 :#3.按键被按下的状态，
       #用户自定义函数
       print("key6 is downing")
    key6_status=KEY6.value()	#获取最新状态




#闪烁5次之后，等5秒，5秒之内看下有没有任意一个按键按下，有的话，进入调参模式，没有的话，比赛模式
num=0
blue_led.on()
for num in range(10):  # 迭代 10 到 20 (不包含) 之间的数字
    blue_led.toggle()
    time.sleep_ms(200)
    print(num)
blue_led.off()


num=0
for num in range(10):  # 迭代 10 到 20 (不包含) 之间的数字
    blue_led.toggle()
    if task_mode==1:#调参模式
        break
    time.sleep_ms(100)
    print(num)

blue_led.off()

g_thread_red00=[(15, 25, 10, 25, -5, 20)]
#绿(24, 52, -40, -4, 0, 34)
while(True):
    if task_mode==1:#调参模式[15, 25, 10, 25, -5, 20]  [g_thread_red][thresholds[threshold_index]]
       #print("tiaocan mode")
        clock.tick()
        img = sensor.snapshot()

        lcd_img =img.scale(0.4,0.5)

        lcd_img.draw_string(0,0,"par_index: %d "% (par_index))
        lcd_img.draw_string(0,10,"rL:%d,%d"% (g_thread_red[0],g_thread_red[1]),color= [200, 0, 0])
        lcd_img.draw_string(0,20,"rA:%d,%d"% (g_thread_red[2],g_thread_red[3]),color= [200, 0, 0])
        lcd_img.draw_string(0,30,"rB:%d,%d"% (g_thread_red[4],g_thread_red[5]),color= [200, 0, 0])
        lcd_img.draw_string(0,40,"gL:%d,%d"% (g_thread_green[0],g_thread_green[1]),color=[0, 255, 0])
        lcd_img.draw_string(0,50,"gA:%d,%d"% (g_thread_green[2],g_thread_green[3]),color=[0, 255, 0])
        lcd_img.draw_string(0,60,"gB:%d,%d"% (g_thread_green[4],g_thread_green[5]),color=[0, 255, 0])
        lcd_img.draw_string(0,70,"gL:%d,%d"% (g_thread_green[0],g_thread_green[1]),color=[0, 91, 170])
        lcd_img.draw_string(0,80,"gA:%d,%d"% (g_thread_green[2],g_thread_green[3]),color=[0, 91, 170])
        lcd_img.draw_string(0,90,"gB:%d,%d"% (g_thread_green[4],g_thread_green[5]),color=[0, 91, 170])
        lcd.display(lcd_img)

        if 0<=par_index<6:
            threadtemp = g_thread_red

        elif  6<=par_index<12:
            threadtemp = g_thread_green


        elif  12<=par_index<18:
            threadtemp = g_thread_blue


        print(threadtemp)
        blob = img.find_blobs([threadtemp], area_threshold=300, margin=10)
            #寻找对应阈值的色块，阈值小于300像素的色块过滤掉，合并相邻像素在10个像素内的色块
        if blob:                                            #如果找到了目标颜色
                print("here0000")
                for b in blob:
                #迭代找到的目标颜色区域
                    lcd_img.draw_cross(int(b[5]*0.4), int(b[6]*0.5))                  #画十字 cx,cy
        #            blob.cx() 返回色块的外框的中心x坐标（int），也可以通过blob[5]来获取。
        #            blob.cy() 返回色块的外框的中心y坐标（int），也可以通过blob[6]来获取。
#                    lcd_img.draw_edges(b.min_corners(), color=(0,255,0))#画框
                    lcd.display(lcd_img)


        if key4val==1:
                    print("key4--------")
                    key4val=0
                    print("-@@red--start")
                    print(g_thread_red[0])
                    print(g_thread_red[1])
                    print(g_thread_red[2])
                    print(g_thread_red[3])
                    print(g_thread_red[4])
                    print(g_thread_red[5])
                    print("-@@red--end")

                    print("-----write data to file---")

                    f =open("save1.txt","w")
                    #写入数据
                    f.seek(0)
                    f.write(str(g_thread_red[0])+","+str(g_thread_red[1])+","+str(g_thread_red[2])+","+str(g_thread_red[3])+","+str(g_thread_red[4])+","+str(g_thread_red[5])+","+\
                            str(g_thread_green[0])+","+str(g_thread_green[1])+","+str(g_thread_green[2])+","+str(g_thread_green[3])+","+str(g_thread_green[4])+","+str(g_thread_green[5])+","+\
                            str(g_thread_blue[0])+","+str(g_thread_blue[1])+","+str(g_thread_blue[2])+","+str(g_thread_blue[3])+","+str(g_thread_blue[4])+","+str(g_thread_blue[5]))
                    time.sleep_ms(10) #等待写入完成
                    f.seek(0)
            #        f.flush() #缓存刷新
                    f.close() #关闭文件
                    task_mode=0
                    print("write ok and close\r\n")


    elif task_mode==0:  #
       print("game mode")
       print("-@@red--start")
       print(g_thread_red[0])
       print(g_thread_red[1])
       print(g_thread_red[2])
       print(g_thread_red[3])
       print(g_thread_red[4])
       print(g_thread_red[5])
       print("-@@red--end")
       waitkeyflag =1
       break  #跳出这个循环

#如果上面5秒之内没有按键按下，错过这个时间点，按键1后面执行的是第二阶段的代码
if key1_step==0:
    key1_step=1


print("while(True)...")
while(True):
    clock.tick()

    if waitkeyflag==0:
        wait_key()
#        print(waitkeyflag)
#        print("wait key00")
    elif waitkeyflag==1 :
        img = sensor.snapshot()
        lcd_img =img.scale(0.4,0.5)
        lcd_img.draw_string(0,0,"par_index: %d "% (par_index))
        lcd.display(lcd_img)
        print(clock.fps())

#    print(task_mode)
#    print("key1_step="+str(key1_step))

卡机

ooolmf
关注
专栏目录
大华摄像机调试以及保存视频
u013548568的博客
06-09 8553
1）下载configtool并安装 https://www.onlinedown.net/soft/1108284.htm 2）修改摄像机目标ip地址，使该地址的前三位与电脑主机ip一致，最后一位无所谓，至于子网掩码以及网关，与本机保持一致，其中子网掩码以及网关需要在cmd窗口里输入 ipconfig/all 3)在网页中输入修改好的ip地址，10.1.23.1，输入用户名密码即可进入界面 4)使用python来保存视频 import cv2 print("hello") #video_str
mv调参保存
lmf666的博客
08-15 184
ddd
mv:按键调参数，定时器，文件保存参数，调出参数01
lmf666的博客
08-08 400
K1—开机5秒之内检测判断K1有没有暗下来，如果暗下来，那么进入调参模式。0-5是红色阈值，LAB，Lmin ,Lmax,Amin,Amax,Bmin,Bmax;注意，保存数据下，要重新按下板子的rst复位按键，才可以看到U盘的文件的数据有变化。读取数据之后，如果要重新读取，记得把读取指针放到最开头，f.seek(0)；K2是调参模式下，那么对数据+5,5是参数变化步长，具体可以根据实际调节；注意，加5和减5的代码，改进版本要加边界处理，因为数据是。K5是参数选择0-15，按下，参数-1；
移动机器人激光SLAM导航（五）：Cartographer SLAM 篇
qq_42994487的博客
02-14 1751
移动机器人激光SLAM导航（四）：Cartographer SLAM 篇
Open MV形状识别
zhaoyufei04的博客
06-02 1934
圆形识别用的是霍夫圆检测算法矩形识别用的是四元检测算法，运用在Apriltag。特点：识别任意大小，任意角度的矩形，灵活。对于图像失真、畸变是没有要求的。
5分钟上手Open MV颜色识别
zhaoyufei04的博客
06-01 462
5分钟上手openmv的颜色识别
（二）理解word2vec：实践篇
anshuai_aw1的博客
11-20 3796
在《（一）理解word2vec：原理篇》中，我已经介绍了word2vec的相关应用和原理。在这篇博客中，我主要介绍word2vec的实践。 本篇博客的基础实践代码仍然参考刘新建老师的博客，在他文章的基础上，我又扩展了一些功能。 我用的实现word2vec的包是gensim（官方github）。gensim是一款开源的第三方Python工具包，用于从原始的非结构化的文本中，无监督地学习到文本隐层...
STM32自己从零开始实操01:电源部分原理图
小醒爱硬件的博客
04-23 2177
在听完老师关于 STM32 物联网项目的所有硬件课程之后，就是感觉自己云里雾里，明明课程都认真听完了，笔记也认真记录，但是就是感觉学到的知识还不是自己。遂决定站在老师的肩膀上自己开始设计项目，将知识变成自己的！也是自己开始在空白的PCB原理图上按照项目需要开始设计才发现有。
帧间预测：运动估计和运动补偿
热门推荐
baidu_35812312的博客
04-27 2万+
运动补偿是通过先前的局部图像来预测、补偿当前的局部图像，它是减少帧序列冗余信息的有效方法。运动估计是从视频序列中抽取运动信息的一整套技术。运动估计与运动补偿技术　　　　MPEG-4采用I-VOP、P-VOP、B-VOP三种帧格式来表征不同的运动补偿类型。它采用了H.263中的半像素搜索（half pixel searching）技术和重叠运动补偿（overlapped motion compens...
R语言基于LASSO进行特征筛选（feature selection）
data+scenario+science+insight
08-15 7607
R语言基于LASSO进行特征筛选（feature selection） 对一个学习任务来说，给定属性集，有些属性很有用，另一些则可能没什么用。这里的属性即称为“特征”(feature)。对当前学习任务有用的属性称为“相关特征”(relevant feature)、没什么用的属性称为“无关特征”(irrelevant feature)。从给定的特征集合中选择出相关特征子集的过程，即“特征选择”(feature selection) 当数据预处理完成后，我们需要选择有意义的特征输入机器学习的算法和模型进行
模型泛化能力提升术：如何通过特征选择强化机器学习模型推广效果
[模型泛化能力提升术：如何通过特征选择强化机器学习模型推广效果](https://static.wixstatic.com/media/f9980f_46846ad724114893bc8481b2438eb27a~mv2.jpg/v1/fill/w_980,h_551,al_c,q_85,usm_0.66_1.00_0.01,enc_...
智能问答系统：问句预处理、检索和深度语义匹配技术
最AI的小PAI
06-21 1万+
更多干货内容敬请关注「平安寿险PAI」（公众号ID：PAL-AI），文末有本期分享内容资料获取方式。 智能问答系统是人机交互的核心技术之一，常见的应用场景主要是智慧客服。通过构建该系统，机器人可以快速找到与用户问题相匹配的答案并自动回答，从而大大减少企业的人力成本；除了提供专业领域的问答功能外，还可实现闲聊、私人助手等问答服务。 尽管业界在智能问答领域已经取得了令人瞩目的成就，但是智能问答系统还远...
基于互联网的认知行为疗法对慢性疼痛的有效性和安全性：荟萃分析
互联网干预30（2022）100587慢性疼痛患者基于互联网的认知行为治疗的埃西岛Terpstra a，b，*，Rosalie van der Vaarta，Sylvia van Beugen a，Ro X y A. van Eersela，IoannaGkikaa，DorottyaErd oResa，...
上海交通大学计算机学院于欣阳,GitHub - zhongzebin/SJTU-RM-CV-2019: 上海交通大学 RoboMaster 2019赛季 视觉代码...
weixin_30624835的博客
07-26 1431
上海交通大学 RoboMaster 2019赛季 视觉代码本代码是上海交通大学RoboMaster2019赛季步兵车辆的视觉部分，分为三个模块:装甲板识别，能量机关，以及封装的设备驱动和配置文件。可以提取能量机关以外的模块并修改main函数直接作为哨兵识别代码。本代码统一使用640×480大小的图像进行处理作者负责部分微信号唐欣阳自瞄装甲板识别xinyang_tang卫志坤自瞄装甲板识别孙加桐能量...
Java-网络
最新发布
2301_81543552的博客
09-14 335
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 332
如果在新建Android项目时报错：Read timed out或者connect timed out。
上传文件到钉盘流程详解
jspyth的博客
09-14 417
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
图像分割入门：双峰法阈值确定与MATLAB实现
本篇文章主要介绍了图像分割的基本概念和直方图阈值的双峰法在图像分割中的应用。图像分割是计算机视觉领域中的一个重要任务，它旨在将图像分解为具有特定特性的区域，如目标（前景）和背景。文章首先阐述了图像分割...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值