精华内容
下载资源
问答
  • Python写自动化之设置Windows自动登录
    千次阅读
    2015-03-25 15:16:34

    在某些情况下,测试过程会涉及到操作系统的重启过程,比如说测试操作系统重启后,程序的启动时间评测;这时如果操作系统设置了用户名密码的情况下,就会涉及到如何实现Windows的自动登录。

    首先,看下Windows如何实现自动登录,看下如何手动操作吧,百度经验:http://jingyan.baidu.com/article/54b6b9c0d7bf6c2d583b47f2.html

    了解了手动操作的过程,自动化中如何实现呢?修改注册表......

    ok,看下HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Winlogon项下,含有默认用户名、密码、是否自动登录等信息,那么只需要保存用户名密码到此项下,系统就可以自动登录了,看下代码:

    def SetAutoLoginWin(username,password):
        """
        | #设置window自动登录
        """
        key = None
        syswow = os.getenv("windir")+"\\SysWOW64"
        for i in range(2):
            try:
                if os.path.exists(syswow):
                    key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, r"Software\Microsoft\Windows NT\CurrentVersion\Winlogon", 0, _winreg.KEY_ALL_ACCESS|win32con.KEY_WOW64_64KEY)
                else:
                    key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, r"Software\Microsoft\Windows NT\CurrentVersion\Winlogon", 0, _winreg.KEY_ALL_ACCESS)
            except:
                pass
    
            if key:
                break
            else:
                _winreg.CreateKey(_winreg.HKEY_LOCAL_MACHINE,r"Software\Microsoft\Windows NT\CurrentVersion\Winlogon")
    
        try:
            _winreg.SetValueEx(key,"DefaultUserName",0,_winreg.REG_SZ,username)
            _winreg.SetValueEx(key,"DefaultPassword",0,_winreg.REG_SZ,password)
            _winreg.SetValueEx(key,"AutoAdminLogon",0,_winreg.REG_SZ,"1")
            _winreg.SetValueEx(key,"ForceAutoLogon",0,_winreg.REG_SZ,"1")
        except:
            return False
        return True

    同样,清除自动化登录操作,也比较简单,只需要将注册表项清除掉就OK了,代码如下

    #清除window自动登录
    def DelAutoLoginWin():
        """
        | #清除window自动登录
        """
        items=("DefaultUserName","DefaultPassword","AutoAdminLogon","ForceAutoLogon")
        for item in items:
            DeleteRegValue(r"HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Winlogon",item)
    

    这样,自动化中涉及到需要重启的操作时,我们就可以让系统自动登录,并继续执行脚本了···

    转载请注明:http://blog.csdn.net/sogouauto

    探索测试奥义,交流测试技术,欢迎关注“搜狗测试”

    更多相关内容
  • 自动化系统作业.pptx
  • robotframework自动化系列:登陆操作

    千次阅读 2019-09-23 15:36:16
    robotframework自动化系统登录 robotframework对于编程能力比较弱的测试人员而言,真的是雪中送炭!我们可以使用robotframework根据之前完成的测试用例,一步步完善自动化测试。在整个测试过程而言,最常见的就是...

    robotframework自动化系统:登录

    robotframework对于编程能力比较弱的测试人员而言,真的是雪中送炭!我们可以使用robotframework根据之前完成的测试用例,一步步完善自动化测试。在整个测试过程而言,最常见的就是登陆、新增、修改、删除、查询等操作,其他的操作都是在这个基础上进行演练。这里就先简单说明一下登陆的操作。

    登录

    对于登录而已,我们已经非常熟悉,下面是登录的测试用例的几种情况,如图
    登录测试用例
    这里首先编写的是登录成功的测试用例
    针对登录测试用例,我们一般的操作步骤如下

    1. 打开浏览器,输入web登录url地址
    2. 在打开的页面中输入登录的正确用户名
    3. 在登录页面中输入用户名匹配的密码
    4. 点击登录按钮
      接下来,我们尝试用robotframework进行测试用例编写
      登录成功
      这里展示了登录的一个测试用例信息,在思维导图中我们可以看出,实际上这上面的四个步骤都是可以复用的,区别就是数据不同而已。而robotframework有一个最大的特点就是分层,所以这里的打开浏览器、输入用户名、输入密码以及点击登录都可以封装成一个关键字。
      新建一个资源文件,将上面四个封装成关键字如图所示
      基本关键字
      封装之后,那么我们的测试用例可以修改成这样的哟,如图
      关键字封装
      说明
      登录用例中的\({url}、\){username}、${password}则是将代码中经常使用的不变的参数设置为变量形式,如图所示
      变量
      而用例中最主要的就是断言,这里只断言了登录成功的跳转页面是否和预期的url是否一致,我们还可以增加,登录成功后返回的登录页面的用户名提示是否和登录的用户名一致。
      到此,一个用例已经基本构建完成,那么对于登录用例中,步骤都是一致的,但是区别的就是登录的用户和密码是不一样,这里我们应该怎么操作呢?这里我们下次构架再进行完善......

    转载于:https://www.cnblogs.com/LOVEYU/p/7793198.html

    展开全文
  • 基于Python的作业自动批改系统

    万次阅读 多人点赞 2022-01-17 19:41:22
    退1024步讲,要不要自己做一个自动批改的功能啊?万一哪天孩子要用呢! 昨晚我做了一个梦,梦见我实现了这个功能,如下图所示: 功能简介: 作对了,能打对号;做错了,能打叉号;没做的,能补上答案。 醒来后,我...
    1. 同级新建fonts文件夹里拷贝一些字体文件,从这里找C:\Windows\Fonts,几十个就行。
    2. get_character_pic.py 生成字体
    3. cnn.py 训练数据
    4. main.py 裁剪指定图片并识别,素材图片新建imgs文件夹,在imgs/question.png下,结果文件保存在imgs/result.png。
    5. 注意如果识别不成功,很可能是question.png的字体你没有训练(这幅图的字体是方正书宋简体,但是你只训练了楷体),这时候可以使用楷体自己编一个算式图。

    一、亮出效果

    最近在线教育行业遭遇一点小波折,一些搜题、智能批改类的功能要下线。

    退1024步讲,要不要自己做一个自动批改的功能啊?万一哪天孩子要用呢!

    昨晚我做了一个梦,梦见我实现了这个功能,如下图所示:

    功能简介: 作对了,能打对号;做错了,能打叉号;没做的,能补上答案。

    醒来后,我环顾四周,赶紧再躺下,希望梦还能接上。

    二、实现步骤

    基本思路

    其实,搞定两点就成,第一是能识别数字,第二是能切分数字。

    首先得能认识5是5,这是前提条件,其次是能找到5、6、7、8这些数字区域的位置。

    前者是图像识别,后者是图像切割

    • 对于图像识别,一般的套路是下面这样的(CNN卷积神经网络):
    输入
    识别输出
    字符图片数据集
    训练
    训练结果
    字符图片
    字符值
    • 对于图像切割,一般的套路是下面的这样(横向纵向投影法):

    既然思路能走得通,那么咱们先搞图像识别。

    要自己搞图像识别,得准备数据->训练数据并保存模型->使用训练模型预测结果

    2.1 准备数据

    对于男友,找一个油嘴滑舌的花花公子,不如找一个闷葫芦IT男,亲手把他培养成你期望的样子。

    咱们不用什么官方的mnist数据集,因为那是官方的,不是你的,你想要添加±×÷它也没有。

    有些通用的数据集,虽然很强大,很方便,但是一旦放到你的场景中,效果一点也不如你的愿。

    只有训练自己手里的数据,然后自己用起来才顺手。更重要的是,我们享受创造的过程。

    假设,我们只给口算做识别,那么我们需要的图片数据有如下几类:

    索引:0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
    字符:0 1 2 3 4 5 6 7 8 9  =  +  -  ×  ÷
    

    如果能识别这些,基本上能满足整数的加减乘除运算了。

    好了,图片哪里来?!

    是啊,图片哪里来?

    吓得我差点从梦里醒来,500万都规划好该怎么花了,居然双色球还没有选号!

    梦里,一个老者跟我说,图片要自己生成。我问他如何生成,他呵呵一笑,消失在迷雾中……

    仔细一想,其实也不难,打字我们总会吧,生成数字无非就是用代码把字写在图片上。

    字之所以能展示,主要是因为有字体的支撑。

    如果你用的是windows系统,那么打开KaTeX parse error: Undefined control sequence: \Windows at position 3: C:\̲W̲i̲n̲d̲o̲w̲s̲\Fonts这个文件夹,你会发现好多字体。

    我们写代码调用这些字体,然后把它打印到一张图片上,是不是就有数据了。

    而且这些数据完全是由我们控制的,想多就多,想少就少,想数字、字母、汉字、符号都可以,今天你搞出来数字识别,也就相当于你同时拥有了所有识别!想想还有点小激动呢!

    看看,这就是打工和创业的区别。你用别人的数据相当于打工,你是不用操心,但是他给你什么你才有什么。自己造数据就相当于创业,虽然前期辛苦,你可以完全自己把握节奏,需要就加上,没用就去掉。

    2.1.1 准备字体

    建一个fonts文件夹,从字体库里拷一部分字体放进来,我这里是拷贝了13种字体文件。

    好的,准备工作做好了,肯定很累吧,休息休息休息,一会儿再搞!

    2.1.2 生成图片

    代码如下,可以直接运行。

    from __future__ import print_function
    from PIL import Image
    from PIL import ImageFont
    from PIL import ImageDraw
    import os
    import shutil
    import time
    
    # %% 要生成的文本
    label_dict = {0: '0', 1: '1', 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9', 10: '=', 11: '+', 12: '-', 13: '×', 14: '÷'}
    
    # 文本对应的文件夹,给每一个分类建一个文件
    for value,char in label_dict.items():
        train_images_dir = "dataset"+"/"+str(value)
        if os.path.isdir(train_images_dir):
            shutil.rmtree(train_images_dir)
        os.makedirs(train_images_dir)
    
    # %% 生成图片
    def makeImage(label_dict, font_path, width=24, height=24, rotate = 0):
    
        # 从字典中取出键值对
        for value,char in label_dict.items():
            # 创建一个黑色背景的图片,大小是24*24
            img = Image.new("RGB", (width, height), "black") 
            draw = ImageDraw.Draw(img)
            # 加载一种字体,字体大小是图片宽度的90%
            font = ImageFont.truetype(font_path, int(width*0.9))
            # 获取字体的宽高
            font_width, font_height = draw.textsize(char, font)
            # 计算字体绘制的x,y坐标,主要是让文字画在图标中心
            x = (width - font_width-font.getoffset(char)[0]) / 2
            y = (height - font_height-font.getoffset(char)[1]) / 2
            # 绘制图片,在那里画,画啥,什么颜色,什么字体
            draw.text((x,y), char, (255, 255, 255), font)
            # 设置图片倾斜角度
            img = img.rotate(rotate)
            # 命名文件保存,命名规则:dataset/编号/img-编号_r-选择角度_时间戳.png
            time_value = int(round(time.time() * 1000))
            img_path = "dataset/{}/img-{}_r-{}_{}.png".format(value,value,rotate,time_value)
            img.save(img_path)
            
    # %% 存放字体的路径
    font_dir = "./fonts"
    for font_name in os.listdir(font_dir):
        # 把每种字体都取出来,每种字体都生成一批图片
        path_font_file = os.path.join(font_dir, font_name)
        # 倾斜角度从-10到10度,每个角度都生成一批图片
        for k in range(-10, 10, 1):	
            # 每个字符都生成图片
            makeImage(label_dict, path_font_file, rotate = k)
    

    上面纯代码不到30行,相信大家应该能看懂!看不懂不是我的读者。

    核心代码就是画文字。

    draw.text((x,y), char, (255, 255, 255), font)
    

    翻译一下就是:使用某字体在黑底图片的(x,y)位置写白色的char符号。

    核心逻辑就是三层循环。

    取一种字体
    取一个角度
    取一个字符
    再来一次
    再来一次
    再来一次
    字体库
    角度库
    字符库
    写到图片上

    如果代码你运行的没有问题,最终会生成如下结果:


    好了,数据准备好了。总共15个文件夹,每个文件夹下对应的各种字体各种倾斜角的字符图片3900个(字符15类×字体13种×角度20个),图片的大小是24×24像素。

    有了数据,我们就可以再进行下一步了,下一步是训练使用数据。

    2.2 训练数据

    2.2.1 构建模型

    你先看代码,外行感觉好深奥,内行偷偷地笑。

    # %% 导入必要的包 
    import tensorflow as tf
    import numpy as np
    from tensorflow.keras import layers
    from tensorflow.keras.models import Sequential
    import pathlib
    import cv2
    
    # %% 构建模型
    def create_model():
        model = Sequential([
            layers.experimental.preprocessing.Rescaling(1./255, input_shape=(24, 24, 1)),
            layers.Conv2D(24,3,activation='relu'),
            layers.MaxPooling2D((2,2)),
            layers.Conv2D(64,3, activation='relu'),
            layers.MaxPooling2D((2,2)),
            layers.Flatten(),
            layers.Dense(128, activation='relu'),
            layers.Dense(15)]
        )
        
        model.compile(optimizer='adam',
                    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                    metrics=['accuracy'])
    
        return model
    

    这个模型的序列是下面这样的,作用是输入一个图片数据,经过各个层揉搓,最终预测出这个图片属于哪个分类。

    输入: 图片24*24像素
    卷积层1 Conv2D
    池化层1 MaxPooling2D
    卷积层2 Conv2D
    池化层2 MaxPooling2D
    全连接层1 Dense 128
    全连接层2 Dense 15
    0: 30%
    1: 20%
    2: 0.5%
    ...
    =: 1%

    这么多层都是干什么的,有什么用?和衣服一样,肯定是有用的,内衣、衬衣、毛衣、棉衣各有各的用处。

    2.2.2 卷积层 Conv2D

    各个职能部门的调查员,搜集和整理某单位区域内的特定数据。
    我们输入的是一个图像,它是由像素组成的,这就是 R e s c a l i n g ( 1. / 255 , i n p u t s h a p e = ( 24 , 24 , 1 ) ) Rescaling(1./255, input_shape=(24, 24, 1)) Rescaling(1./255,inputshape=(24,24,1))中,input_shape输入形状是24*24像素1个通道(彩色是RGB 3个通道)的图像。

    卷积层代码中的定义是Conv2D(24,3),意思是用3*3像素的卷积核,去提取24个特征。

    我把图转到地图上来,你就能理解了。以我大济南的市中区为例子。

    卷积的作用就相当于从地图的某级单位区域中收集多组特定信息。比如以小区为单位去提取住宅数量、车位数量、学校数量、人口数、年收入、学历、年龄等等24个维度的信息。小区相当于卷积核。

    提取完成之后是这样的。


    第一次卷积之后,我们从市中区得到N个小区的数据。

    卷积是可以进行多次的。

    比如在小区卷积之后,我们还可在小区的基础上再来一次卷积,在卷积就是街道了。

    通过再次以街道为单位卷积小区,我们就从市中区得到了N个街道的数据。

    这就是卷积的作用。

    通过一次次卷积,就把一张大图,通过特定的方法卷起来,最终留下来的是固定几组有目的数据,以此方便后续的评选决策。这是评选一个区的数据,要是评选济南市,甚至山东省,也是这么卷积。这和现实生活中评选文明城市、经济强省也是一个道理。

    2.2.3 池化层 MaxPooling2D

    说白了就是四舍五入。

    计算机的计算能力是强大的,比你我快,但也不是不用考虑成本。我们当然希望它越快越好,如果一个方法能省一半的时间,我们肯定愿意用这种方法。

    池化层干的就是这个事情。
    池化的代码定义是这样的 M a x P o o l i n g 2 D ( ( 2 , 2 ) ) MaxPooling2D((2,2)) MaxPooling2D((2,2)),这里是最大值池化。其中(2,2)是池化层的大小,其实就是在2*2的区域内,我们认为这一片可以合成一个单位。

    再以地图举个例子,比如下面的16个格子里的数据,是16个街道的学校数量。

    为了进一步提高计算效率,少计算一些数据,我们用2*2的池化层进行池化。

    池化的方格是4个街道合成1个,新单位学校数量取成员中学校数量最大(也有取最小,取平均多种池化)的那一个。池化之后,16个格子就变为了4个格子,从而减少了数据。

    这就是池化层的作用。

    2.2.4 全连接层 Dense

    弱水三千,只取一瓢。

    在这里,它其实是一个分类器。

    我们构建它时,代码是这样的 D e n s e ( 15 ) Dense(15) Dense(15)

    它所做的事情,不管你前面是怎么样,有多少维度,到我这里我要强行转化为固定的通道。

    比如识别字母a~z,我有500个神经元参与判断,但是最终输出结果就是26个通道(a,b,c,……,y,z)。

    我们这里总共有15类字符,所以是15个通道。给定一个输入后,输出为每个分类的概率。

    其他类型的层
    全连接层1 Dense 128
    1
    全连接层2 Dense 15
    2
    3
    4
    5
    ...
    127
    128
    1: 30%
    2: 20%
    3: 0.5%
    ...
    15: 1%

    注意:上面都是二维的输入,比如24×24,但是全连接层是一维的,所以代码中使用了 l a y e r s . F l a t t e n ( ) layers.Flatten() layers.Flatten()将二维数据拉平为一维数据([[11,12],[21,22]]->[11,12,21,22])。

    对于总体的模型,调用 m o d e l . s u m m a r y ( ) model.summary() model.summary()打印序列的网络结构如下:

    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    rescaling_2 (Rescaling)      (None, 24, 24, 1)         0         
    _________________________________________________________________
    conv2d_4 (Conv2D)            (None, 22, 22, 24)        240       
    _________________________________________________________________
    max_pooling2d_4 (MaxPooling2 (None, 11, 11, 24)        0         
    _________________________________________________________________
    conv2d_5 (Conv2D)            (None, 9, 9, 64)          13888     
    _________________________________________________________________
    max_pooling2d_5 (MaxPooling2 (None, 4, 4, 64)          0         
    _________________________________________________________________
    flatten_2 (Flatten)          (None, 1024)              0         
    _________________________________________________________________
    dense_4 (Dense)              (None, 128)               131200    
    _________________________________________________________________
    dense_5 (Dense)              (None, 15)                1935      
    =================================================================
    Total params: 147,263
    Trainable params: 147,263
    Non-trainable params: 0
    _________________________________________________________________
    

    我们看到conv2d_5 (Conv2D) (None, 9, 9, 64) 经过2*2的池化之后变为max_pooling2d_5 (MaxPooling2 (None, 4, 4, 64)(None, 4, 4, 64) 再经过 F l a t t e n Flatten Flatten拉成一维之后变为(None, 1024),经过全连接变为(None, 128)再一次全连接变为(None, 15),15就是我们的最终分类。这一切都是我们设计的。

    m o d e l . c o m p i l e model.compile model.compile就是配置模型的几个参数,这个现阶段记住就可以。

    2.2.5 训练数据

    执行就完了。

    # 统计文件夹下的所有图片数量
    data_dir = pathlib.Path('dataset')
    # 从文件夹下读取图片,生成数据集
    train_ds = tf.keras.preprocessing.image_dataset_from_directory(
        data_dir, # 从哪个文件获取数据
        color_mode="grayscale", # 获取数据的颜色为灰度
        image_size=(24, 24), # 图片的大小尺寸
        batch_size=32 # 多少个图片为一个批次
    )
    # 数据集的分类,对应dataset文件夹下有多少图片分类
    class_names = train_ds.class_names
    # 保存数据集分类
    np.save("class_name.npy", class_names)
    # 数据集缓存处理
    AUTOTUNE = tf.data.experimental.AUTOTUNE
    train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
    # 创建模型
    model = create_model()
    # 训练模型,epochs=10,所有数据集训练10遍
    model.fit(train_ds,epochs=10)
    # 保存训练后的权重
    model.save_weights('checkpoint/char_checkpoint')
    

    执行之后会输出如下信息:

    Found 3900 files belonging to 15 classes. 
    Epoch 1/10 122/122 [=========] - 2s 19ms/step - loss: 0.5795 - accuracy: 0.8615 
    Epoch 2/10 122/122 [=========] - 2s 18ms/step - loss: 0.0100 - accuracy: 0.9992 
    Epoch 3/10 122/122 [=========] - 2s 19ms/step - loss: 0.0027 - accuracy: 1.0000 
    Epoch 4/10 122/122 [=========] - 2s 19ms/step - loss: 0.0013 - accuracy: 1.0000 
    Epoch 5/10 122/122 [=========] - 2s 20ms/step - loss: 8.4216e-04 - accuracy: 1.0000 
    Epoch 6/10 122/122 [=========] - 2s 18ms/step - loss: 5.5273e-04 - accuracy: 1.0000 
    Epoch 7/10 122/122 [=========] - 3s 21ms/step - loss: 4.0966e-04 - accuracy: 1.0000 
    Epoch 8/10 122/122 [=========] - 2s 20ms/step - loss: 3.0308e-04 - accuracy: 1.0000 
    Epoch 9/10 122/122 [=========] - 3s 23ms/step - loss: 2.3446e-04 - accuracy: 1.0000 
    Epoch 10/10 122/122 [=========] - 3s 21ms/step - loss: 1.8971e-04 - accuracy: 1.0000
    

    我们看到,第3遍时候,准确率达到100%了。
    最后结束的时候,我们发现文件夹checkpoint下多了几个文件:

    char_checkpoint.data-00000-of-00001
    char_checkpoint.index
    checkpoint
    

    上面那几个文件是训练结果,训练保存之后就不用动了。后面可以直接用这些数据进行预测。

    2.3 预测数据

    终于到了享受成果的时候了。

    # 设置待识别的图片
    img1=cv2.imread('img1.png',0) 
    img2=cv2.imread('img2.png',0) 
    imgs = np.array([img1,img2])
    # 构建模型
    model = create_model()
    # 加载前期训练好的权重
    model.load_weights('checkpoint/char_checkpoint')
    # 读出图片分类
    class_name = np.load('class_name.npy')
    # 预测图片,获取预测值
    predicts = model.predict(imgs) 
    results = [] # 保存结果的数组
    for predict in predicts: #遍历每一个预测结果
        index = np.argmax(predict) # 寻找最大值
        result = class_name[index] # 取出字符
        results.append(result)
    print(results)
    

    我们找两张图片img1.png,img2.png,一张是数字6,一张是数字8,两张图放到代码同级目录下,验证一下识别效果如何。

    图片要通过cv2.imread('img1.png',0) 转化为二维数组结构,0参数是灰度图片。经过处理后,图片转成的数组是如下所示(24,24)的结构:

    我们要同时验证两张图,所以把两张图再组成imgs放到一起,imgs的结构是(2,24,24)

    下面是构建模型,然后加载权重。通过调用predicts = model.predict(imgs)imgs传递给模型进行预测得出predicts

    predicts的结构是(2,15),数值如下面所示:

    [[ 16.134243 -12.10675 -1.1994154 -27.766754 -43.4324 -9.633694 -12.214878 1.6287893 2.562174 3.2222707 13.834648 28.254173 -6.102874 16.76582 7.2586184] [ 5.022571 -8.762314 -6.7466817 -23.494259 -30.170597 2.4392672 -14.676962 5.8255725 8.855118 -2.0998626 6.820853 7.6578817 1.5132296 24.4664 2.4192357]]

    意思是有2个预测结果,每一个图片的预测结果有15种可能。

    然后根据 index = np.argmax(predict) 找出最大可能的索引。

    根据索引找到字符的数值结果是[‘6’, ‘8’]。

    下面是数据在内存中的监控:

    可见,我们的预测是准确的。

    下面,我们将要把图片中数字切割出来,进行识别了。

    之前我们准备了数据,训练了数据,并且拿图片进行了识别,识别结果正确。

    到目前为止,看来问题不大……没有大问题,有问题也大不了。

    下面就是把图片进行切割识别了。

    下面这张大图片,怎么把它搞一搞,搞成单个小数字的图片。

    2.4 切割图像

    上帝说要有光,就有了光。

    于是,当光投过来时,物体的背后就有了影。

    我们就知道了,有影的地方就有东西,没影的地方是空白。

    这就是投影。

    这个简单的道理放在图像切割上也很实用。

    我们把文字的像素做个投影,这样我们就知道某个区间有没有文字,并且知道这个区间文字是否集中。

    下面是示意图:

    2.4.1 投影大法

    最有效的方法,往往都是用循环实现的。

    要计算投影,就得一个像素一个像素地数,查看有几个像素,然后记录下这一行有N个像素点。如此循环。

    首先导入包:

    import numpy as np
    import cv2
    from PIL import Image, ImageDraw, ImageFont
    import PIL
    import matplotlib.pyplot as plt
    import os
    import shutil
    from numpy.core.records import array
    from numpy.core.shape_base import block
    import time
    

    比如说要看垂直方向的投影,代码如下:

    # 整幅图片的Y轴投影,传入图片数组,图片经过二值化并反色
    def img_y_shadow(img_b):
        ### 计算投影 ###
        (h,w)=img_b.shape
        # 初始化一个跟图像高一样长度的数组,用于记录每一行的黑点个数
        a=[0 for z in range(0,h)]
        # 遍历每一列,记录下这一列包含多少有效像素点
        for i in range(0,h):          
            for j in range(0,w):      
                if img_b[i,j]==255:     
                    a[i]+=1  
        return a
    

    最终得到是这样的结构:
    [0, 79, 67, 50, 50, 50, 109, 137, 145, 136, 125, 117, 123, 124, 134, 71, 62, 68, 104, 102, 83, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, ……38, 44, 56, 106, 97, 83, 0, 0, 0, 0, 0, 0, 0]表示第几行总共有多少个像素点,第1行是0,表示是空白的白纸,第2行有79个像素点。

    如果我们想要从视觉呈现出来怎么处理呢?那可以把它立起来拉直画出来。

    1
    .
    5
    .....
    2
    ..
    # 展示图片
    def img_show_array(a):
        plt.imshow(a)
        plt.show()
        
    # 展示投影图, 输入参数arr是图片的二维数组,direction是x,y轴
    def show_shadow(arr, direction = 'x'):
    
        a_max = max(arr)
        if direction == 'x': # x轴方向的投影
            a_shadow = np.zeros((a_max, len(arr)), dtype=int)
            for i in range(0,len(arr)):
                if arr[i] == 0:
                    continue
                for j in range(0, arr[i]):
                    a_shadow[j][i] = 255
        elif direction == 'y': # y轴方向的投影
            a_shadow = np.zeros((len(arr),a_max), dtype=int)
            for i in range(0,len(arr)):
                if arr[i] == 0:
                    continue
                for j in range(0, arr[i]):
                    a_shadow[i][j] = 255
    
        img_show_array(a_shadow)
    

    我们来试验一下效果:

    我们将上面的原图片命名为question.jpg放到代码同级目录。

    # 读入图片
    img_path = 'question.jpg'
    img=cv2.imread(img_path,0) 
    thresh = 200 
    # 二值化并且反色
    ret,img_b=cv2.threshold(img,thresh,255,cv2.THRESH_BINARY_INV) 
    

    二值化并反色后的变化如下所示:

    上面的操作很有作用,通过二值化,过滤掉杂色,通过反色将黑白对调,原来白纸区域都是255,现在黑色都是0,更利于计算。

    计算投影并展示的代码:

    img_y_shadow_a = img_y_shadow(img_b)
    show_shadow(img_y_shadow_a, 'y') # 如果要显示投影
    

    下面的图是上面图在Y轴上的投影

    从视觉上看,基本上能区分出来哪一行是哪一行。

    2.4.2 根据投影找区域

    最有效的方法,往往还得用循环来实现。

    上面投影那张图,你如何计算哪里到哪里是一行,虽然肉眼可见,但是计算机需要规则和算法。

    # 图片获取文字块,传入投影列表,返回标记的数组区域坐标[[左,上,右,下]]
    def img2rows(a,w,h):
        
        ### 根据投影切分图块 ### 
        inLine = False # 是否已经开始切分
        start = 0 # 某次切分的起始索引
        mark_boxs = []
        for i in range(0,len(a)):        
            if inLine == False and a[i] > 10:
                inLine = True
                start = i
            # 记录这次选中的区域[左,上,右,下],上下就是图片,左右是start到当前
            elif i-start >5 and a[i] < 10 and inLine:
                inLine = False
                if i-start > 10:
                    top = max(start-1, 0)
                    bottom = min(h, i+1)
                    box = [0, top, w, bottom]
                    mark_boxs.append(box) 
                    
        return mark_boxs
    

    通过投影,计算哪些区域在一定范围内是连续的,如果连续了很长时间,我们就认为是同一区域,如果断开了很长一段时间,我们就认为是另一个区域。

    通过这项操作,我们就可以获得Y轴上某一行的上下两个边界点的坐标,再结合图片宽度,其实我们也就知道了一行图片的四个顶点的坐标了mark_boxs存下的是[坐,上,右,下]

    如果调用如下代码:

    (img_h,img_w)=img.shape
    row_mark_boxs = img2rows(img_y_shadow_a,img_w,img_h)
    print(row_mark_boxs)
    

    我们获取到的是所有识别出来每行图片的坐标,格式是这样的:[[0, 26, 596, 52], [0, 76, 596, 103], [0, 130, 596, 155], [0, 178, 596, 207], [0, 233, 596, 259], [0, 282, 596, 311], [0, 335, 596, 363], [0, 390, 596, 415]]

    2.4.3 根据区域切图片

    最有效的方法,最终也得用循环来实现。这也是计算机体现它强大的地方。

    # 裁剪图片,img 图片数组, mark_boxs 区域标记
    def cut_img(img, mark_boxs):
    
        img_items = [] # 存放裁剪好的图片
        for i in range(0,len(mark_boxs)):
            img_org = img.copy()
            box = mark_boxs[i]
            # 裁剪图片
            img_item = img_org[box[1]:box[3], box[0]:box[2]]
            img_items.append(img_item)
        return img_items
    

    这一步骤是拿着方框,从大图上用小刀划下小图,核心代码是img_org[box[1]:box[3], box[0]:box[2]]图片裁剪,参数是数组的[上:下,左:右],获取的数据还是二维的数组。

    如果保存下来:

    # 保存图片
    def save_imgs(dir_name, imgs):
     
        if os.path.exists(dir_name):
            shutil.rmtree(dir_name) 
        if not os.path.exists(dir_name):    
            os.makedirs(dir_name)
    
        img_paths = []
        for i in range(0,len(imgs)):
            file_path = dir_name+'/part_'+str(i)+'.jpg'
            cv2.imwrite(file_path,imgs[i])
            img_paths.append(file_path)
        
        return img_paths
    
    # 切图并保存
    row_imgs = cut_img(img, row_mark_boxs)
    imgs = save_imgs('rows', row_imgs) # 如果要保存切图
    print(imgs)
    

    图片是下面这样的:

    2.4.4 循环可去油腻

    还是循环。
    横着行我们掌握了,那么针对每一行图片,我们竖着切成三块是不是也会了,一个道理。

    需要注意的是,横竖是稍微有区别的,下面是上图的x轴投影。

    横着的时候,字与字之间本来就是有空隙的,然后块与块也有空隙,这个空隙的度需要掌握好,以便更好地区分出来是字的间距还是算式块的间距。

    幸好,有种方法叫膨胀。

    膨胀对人来说不积极,但是对于技术来说,不管是膨胀(dilate),还是腐蚀(erode),只要能达到目的,都是好的。

    kernel=np.ones((3,3),np.uint8)  # 膨胀核大小
    row_img_b=cv2.dilate(img_b,kernel,iterations=6) # 图像膨胀6次
    

    膨胀之后再投影,就很好地区分出了块。

    根据投影裁剪之后如下图所示:

    同理,不膨胀可截取单个字符。

    这样,这是一块区域的字符。

    一行的,一页的,通过循环,都可以截取出来。

    有了图片,就可以识别了。有了位置,就可以判断识别结果的关系了。

    下面提供一些代码,这些代码不全,有些函数你可能找不到,但是思路可以参考,详细的代码可以去我的github去看。

    def divImg(img_path, save_file = False):
    
        img_o=cv2.imread(img_path,1) 
        # 读入图片
        img=cv2.imread(img_path,0) 
        (img_h,img_w)=img.shape
        thresh = 200
        # 二值化整个图,用于分行
        ret,img_b=cv2.threshold(img,thresh,255,cv2.THRESH_BINARY_INV) 
    
        # 计算投影,并截取整个图片的行
        img_y_shadow_a = img_y_shadow(img_b)
        row_mark_boxs = img2rows(img_y_shadow_a,img_w,img_h)
        # 切行的图片,切的是原图
        row_imgs = cut_img(img, row_mark_boxs)
        all_mark_boxs = []
        all_char_imgs = []
        # ===============从行切块======================
        for i in range(0,len(row_imgs)):
            row_img = row_imgs[i]
            (row_img_h,row_img_w)=row_img.shape
            # 二值化一行的图,用于切块
            ret,row_img_b=cv2.threshold(row_img,thresh,255,cv2.THRESH_BINARY_INV)
            kernel=np.ones((3,3),np.uint8)
            #图像膨胀6次
            row_img_b_d=cv2.dilate(row_img_b,kernel,iterations=6)
            img_x_shadow_a = img_x_shadow(row_img_b_d)
            block_mark_boxs = row2blocks(img_x_shadow_a, row_img_w, row_img_h)
            row_char_boxs = []
            row_char_imgs = []
            # 切块的图,切的是原图
            block_imgs = cut_img(row_img, block_mark_boxs)
            if save_file:
                b_imgs = save_imgs('cuts/row_'+str(i), block_imgs) # 如果要保存切图
                print(b_imgs)
            # =============从块切字====================
            for j in range(0,len(block_imgs)):
                block_img = block_imgs[j]
                (block_img_h,block_img_w)=block_img.shape
                # 二值化块,因为要切字符图片了
                ret,block_img_b=cv2.threshold(block_img,thresh,255,cv2.THRESH_BINARY_INV)
                block_img_x_shadow_a = img_x_shadow(block_img_b)
                row_top = row_mark_boxs[i][1]
                block_left = block_mark_boxs[j][0]
                char_mark_boxs,abs_char_mark_boxs = block2chars(block_img_x_shadow_a, block_img_w, block_img_h,row_top,block_left)
                row_char_boxs.append(abs_char_mark_boxs)
                # 切的是二值化的图
                char_imgs = cut_img(block_img_b, char_mark_boxs, True)
                row_char_imgs.append(char_imgs)
                if save_file:
                    c_imgs = save_imgs('cuts/row_'+str(i)+'/blocks_'+str(j), char_imgs) # 如果要保存切图
                    print(c_imgs)
            all_mark_boxs.append(row_char_boxs)
            all_char_imgs.append(row_char_imgs)
    
    
        return all_mark_boxs,all_char_imgs,img_o
    

    最后返回的值是3个,all_mark_boxs是标记的字符位置的坐标集合。[左,上,右,下]是指某个字符在一张大图里的坐标,打印一下是这样的:
    [[[[19, 26, 34, 53], [36, 26, 53, 53], [54, 26, 65, 53], [66, 26, 82, 53], [84, 26, 101, 53], [102, 26, 120, 53], [120, 26, 139, 53]], [[213, 26, 229, 53], [231, 26, 248, 53], [249, 26, 268, 53], [268, 26, 285, 53]], [[408, 26, 426, 53], [427, 26, 437, 53], [438, 26, 456, 53], [456, 26, 474, 53], [475, 26, 492, 53]]], [[[20, 76, 36, 102], [38, 76, 48, 102], [50, 76, 66, 102], [67, 76, 85, 102], [85, 76, 104, 102]], [[214, 76, 233, 102], [233, 76, 250, 102], [252, 76, 268, 102], [270, 76, 287, 102]], [[411, 76, 426, 102], [428, 76, 445, 102], [446, 76, 457, 102], [458, 76, 474, 102], [476, 76, 493, 102], [495, 76, 511, 102]]]]

    它是有结构的。它的结构是:

    第一层-数组
    行1
    行2
    第二层-行3
    行4
    行5
    块1
    第三层-块2
    块3
    字符1
    第四层-字符2
    字符3
    左上右下 495, 76, 511, 102

    all_char_imgs这个返回值,里面是上面坐标结构对应位置的图片。img_o就是原图了。

    2.5 识别

    循环,循环,还是TM循环!

    对于识别,2.3 预测数据已经讲过了,那次是对于2张独立图片的识别,现在我们要对整张大图切分后的小图集合进行识别,这就又用到了循环。

    翠花,上代码!

    all_mark_boxs,all_char_imgs,img_o = divImg(path,save)
    model = cnn.create_model()
    model.load_weights('checkpoint/char_checkpoint')
    class_name = np.load('class_name.npy')
    
    # 遍历行
    for i in range(0,len(all_char_imgs)):
        row_imgs = all_char_imgs[i]
        # 遍历块
        for j in range(0,len(row_imgs)):
            block_imgs = row_imgs[j]
            block_imgs = np.array(block_imgs)
            results = cnn.predict(model, block_imgs, class_name)
            print('recognize result:',results)
    

    上面代码做的就是以块为单位,传递给神经网络进行预测,然后返回识别结果。

    针对这张图,我们来进行裁剪和识别。

    看底部的最后一行

    recognize result: ['1', '0', '12', '2', '10']
    recognize result: ['8', '12', '6', '10']
    recognize result: ['1', '0', '12', '7', '10']
    

    结果是索引,不是真实的字符,我们根据字典10: '=', 11: '+', 12: '-', 13: '×', 14: '÷'转换过来之后结果是:

    recognize result: ['1', '0', '-', '2', '=']
    recognize result: ['8', '-', '6', '=']
    recognize result: ['1', '0', '-', '7', '=']
    

    和图片是对应的:

    2.6 计算并反馈

    循环……

    我们获取到了10-2=8-6=2,也获取到了他们在原图的位置坐标[左,上,右,下],那么怎么把结果反馈到原图上呢?

    往往到这里就剩最后一步了。

    再来温习一遍需求:作对了,能打对号;做错了,能打叉号;没做的,能补上答案。

    实现分两步走:计算(是作对做错还是没错)和反馈(把预期结果写到原图上)。

    2.6.1 计算

    python有个函数很强大,就是eval函数,能计算字符串算式,比如直接计算eval("5+3-2")

    所以,一切都靠它了。

    # 计算数值并返回结果  参数chars:['8', '-', '6', '=']
    def calculation(chars):
        cstr = ''.join(chars)
        result = ''
        if("=" in cstr): # 有等号
            str_arr = cstr.split('=')
            c_str = str_arr[0]
            r_str = str_arr[1]
            c_str = c_str.replace("×","*")
            c_str = c_str.replace("÷","/") 
            try:
                c_r = int(eval(c_str))
            except Exception as e:
                print("Exception",e)
    
            if r_str == "":
                result = c_r
            else:
                if str(c_r) == str(r_str):
                    result = "√"
                else:
                    result = "×"
    
        return result
    

    执行之后获得的结果是:

    recognize result: ['8', '×', '4', '=']
    calculate result: 32
    recognize result: ['2', '-', '1', '=', '1']
    calculate result: √
    recognize result: ['1', '0', '-', '5', '=']
    calculate result: 5
    

    2.6.2 反馈

    有了结果之后,把结果写到图片上,这是最后一步,也是最简单的一步。

    但是实现起来,居然很繁琐。

    得找坐标吧,得计算结果呈现的位置吧,我们还想标记不同的颜色,比如对了是绿色,错了是红色,补齐答案是灰色。

    下面代码是在一个图img上,把文本内容text画到(left,top)位置,以特定颜色和大小。

    # 绘制文本
    def cv2ImgAddText(img, text, left, top, textColor=(255, 0, 0), textSize=20):
        if (isinstance(img, np.ndarray)):  # 判断是否OpenCV图片类型
            img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
        # 创建一个可以在给定图像上绘图的对象
        draw = ImageDraw.Draw(img)
        # 字体的格式
        fontStyle = ImageFont.truetype("fonts/fangzheng_shusong.ttf", textSize, encoding="utf-8")
        # 绘制文本
        draw.text((left, top), text, textColor, font=fontStyle)
        # 转换回OpenCV格式
        return cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)
    

    结合着切图的信息、计算的信息,下面代码提供思路参考:

    # 获取切图标注,切图图片,原图图图片
    all_mark_boxs,all_char_imgs,img_o = divImg(path,save)
    # 恢复模型,用于图片识别
    model = cnn.create_model()
    model.load_weights('checkpoint/char_checkpoint')
    class_name = np.load('class_name.npy')
    
    # 遍历行
    for i in range(0,len(all_char_imgs)):
        row_imgs = all_char_imgs[i]
        # 遍历块
        for j in range(0,len(row_imgs)):
            block_imgs = row_imgs[j]
            block_imgs = np.array(block_imgs)
            # 图片识别
            results = cnn.predict(model, block_imgs, class_name)
            print('recognize result:',results)
            # 计算结果
            result = calculation(results)
            print('calculate result:',result)
            # 获取块的标注坐标
            block_mark = all_mark_boxs[i][j]
            # 获取结果的坐标,写在块的最后一个字
            answer_box = block_mark[-1]
            # 计算最后一个字的位置
            x = answer_box[2] 
            y = answer_box[3]
            iw = answer_box[2] - answer_box[0]
            ih = answer_box[3] - answer_box[1]
            # 计算字体大小
            textSize =  max(iw,ih)
            # 根据结果设置字体颜色
            if str(result) == "√":
                color = (0, 255, 0)
            elif str(result) == "×":
                color = (255, 0, 0)
            else:
                color = (192, 192,192)
            # 将结果写到原图上
            img_o = cv2ImgAddText(img_o, str(result), answer_box[2],  answer_box[1],color, textSize)
    # 将写满结果的原图保存
    cv2.imwrite('result.jpg', img_o)
    

    结果是下面这样的:

    展开全文
  • 哈尔滨工业大学实验学院07级制造系统自动化智能小车设计大作业,仅供参考。
  • 哈尔滨工业大学实验学院07级制造系统自动化机械手设计大作业,仅供参考。
  • 1 背景及应用场景 在工业复杂生产环境下,作业人员的安全问题至关重要。大多数工业企业采 用人眼观察视频的方式对作业人员位置进行判断,这种方式长时间会使管理者出 现疲劳问题,效率非常低下,遇到安全...2 系统

    说明:该报告为19级自动化学科前沿讲座大作业,请勿抄袭,经供参考!

    1 背景及应用场景
    在工业复杂生产环境下,作业人员的安全问题至关重要。大多数工业企业采用人眼观察视频的方式对作业人员位置进行判断,这种方式长时间会使管理者出现疲劳问题,效率非常低下,遇到安全问题也不能进行及时的处理。采用图像处理以及深度学习技术使计算机代替人眼去检测和定位人员,不仅可以提高检测的准确率,同时也可以减轻监管人员的工作负担。使用计算机视觉技术,在工厂实现工作服穿戴检测、员工到岗和离岗检测、员工疲劳检测等人员管理的场景 AI化,可以提升工厂人员管理效率并降低企业管理成本。

    在这里插入图片描述

    2 系统预实现目标
    通过摄像头实时采集工厂员工视频流数据,基于所采集的视频流数据实现工业生产环境员工穿戴检测、到离岗检测以及疲劳检测等功能。并且将检测结果反应至控制调度中心,由控制调度中心做出相应的记录展示、提示警报和异常处理等。以上所描述的即为该基于深度学习的工厂人员监测系统预实现的技术和功能层面目标,而该系统所要实现的企业效益目标为利用计算机代替管理人员对生产员工进行标准化、智能化管理,进而减少额外的劳动力费用和降低生产事故发生率等。
    在这里插入图片描述

    3 场景及重难点分析

    在这里插入图片描述

    在这里插入图片描述

    4 系统设计方案
    4.1 系统整体方案

    在这里插入图片描述

    4.2 系统技术架构

    在这里插入图片描述

    4.3 主要算法 Yolov3
    原始 Yolov3 的网络结构如下图所示,主干网络为 Darknet-53 结构,借鉴ResNet 中的残差结构进行网络地搭建.网络本身为全卷积结构,不包含池化层以及全连接层,张量的尺寸变换通过改变卷积核的步长来实现.特征图在网络中会经历 5 次缩小,最终特征图的尺寸等于输入尺寸的 51/2,即 1/32。

    在这里插入图片描述

    Yolov3 借鉴 FPN 的思想,引入了多尺度检测模块,网络的输出层总共包含3 个不同尺度的特征图。具体来说,从主干网络的 8 倍、16 倍以及 32 倍下采样处分别提取特征图进行 3 个尺度的预测,特别地,对于 8 倍和 16 倍下采样的特征图,通过与后一层特征图的上采样(upsampling)结果拼接融合(concat)得到新的特征图进行最终的预测。其中输出层特征图的每一个网格需要预测 3 个目标框,每个预测框(predicted boxes)包含(x,y,w,h,confidence) 5 个参数,另外包含一个类别概率,所以最终每个网格需要预测的参数总共为 18。Yolov3 网络同样引入了 anchor 机制,通过 anchor 的设置引导网络的训练.通过维度聚类算法,对数据集所有样本中真实目标框(ground-truth boxes)的尺寸进行聚类分析,得出 9 组不同的宽高组合,进一步将 9 组数据分为 3 个大组,分别分配给 3 个不同的尺度,每个尺度包含 3 个不同的宽高组合,通过不同尺寸 anchor的设置来实现对不同尺度目标的检测。

    4.4 数据采集与模型迭代
    原始数据采集:从视频片段中采样得到数据集,模拟违规。
    违规规则定义:将业务规则转化成单帧物体检测的规则。
    单帧图像违规规则判断:违规是否持续了一段时间(真的发生了违规,还是某一两帧模型的误判)。
    在模型迭代优化中,同步进行:①Bad Case 数据的收集与标注 扩充数据集,尽量涵盖数据集中未出现的情景。②检查已有的数据标注 提高数据质量。③将违规行为检测问题分解为“单帧图像的物体检测问题”与“聚合到时间维度的规则
    判断问题”。
    优化:①通过多次试验,调整规则的阈值条件,使单帧检测效果提升。②通过合适的时间聚合条件,将单帧违规信息聚合到事件维度,提高事件级别的识别准确率(Precision)。③迭代期间模型试运行测试时,收集 Bad Case 数据,追加标注数据进行迭代训练。

    在这里插入图片描述

    5 系统成本估算

    在这里插入图片描述

    6 道德伦理问题
    该系统中需要进行人脸识别、人脸特征提取等涉及员工生物特征的采集与存储等处理,因此存在一定的安全隐患与道德伦理问题。人脸识别系统通常是专有的并且保密,但是有专家称,大多数系统涉及一个多阶段过程,该过程通过深度学习对大量数据进行大规模神经网络训练。为了使人脸识别算法正常工作,必须对大型图像数据集进行训练和测试,理想情况下,必须在不同的光照条件和不同的角度多次捕获这些图像,大多数员工未经许可即被收集人脸图像。
    人脸识别信息以或显或隐的方式表征着自然人的人格,一旦被非法收集、使用、存储、传输、披露,对信息主体造成歧视、人格尊严贬损和隐私泄露等后果可能伴随一生。因此,属于敏感个人信息的人脸识别信息被非法处理的后果较一般个人信息更为严重,需要法律的特殊保护。
    规制人脸识别技术应用带来的风险、严格保护人脸识别信息的前提是明确人脸识别信息在法律上的属性。我国暂未出台专门保护人脸识别信息的法律,保护人脸识别信息主要依据现行法中关于敏感个人信息、一般个人信息和隐私权的规定。个人信息保护法为保护人脸识别信息构建了严格的事前信息处理规则,除此之外还为侵害人脸识别信息的行为规定了罚款、吊销营业执照、损害赔偿等行政、民事乃至刑事责任,以增强对违规使用人脸识别技术、侵害人脸识别信息的行为的威慑力。而对于企业本身来说,必须加强监管、提高技术透明度,防止员工人脸特征等信息的泄露和被非法使用。

    展开全文
  • 编组站综合自动化系统(CIPS)

    千次阅读 2021-08-08 00:57:43
    同时也适用于调车作业繁忙的区段站、工矿企业及港口等铁路车站的综合自动化系统概述CIPS编组站综合集成自动化系统是世界首创完全自主知识产权的管控一体化综合平台,是编组站自动化控制系统和综合 管理信息系统的...
  • 自己做作业做的jboa办公自动化系统,包括审批与请假系统,无bug。供大家参考。
  • 保险行业的自动化场景

    千次阅读 2022-01-05 11:32:56
    中小险企借助保险科技实现业务创新和差异发展,帮助企业破解经营困局。 过去几十年,中国的人口红利为保险业提供了广阔的发展空间,保险企业大多通过粗放式的发展模式快速抢占市场实现规模扩张。 近几年,中国...
  • 002仓储物流自动化系统常见哪些设备? 上次解释“001什么是仓储物流自动化”知道了一个仓储物流中心里要实现系统自动化,里边是由各种设备互相配合而完成的。那在仓储物流中心里常见的有哪些设备呢? 直接...
  • 自动化模型构建的核心流程四、AutoML系统的两种模式1.基于专家知识与AutoML系统协作增强的模式2.免代码(code free)模式五、总结 一、需求背景 由于机器学习技术在金融、广告、推荐系统和用户行为分析等多个方面的...
  • 作业管理系统源码带论文

    热门讨论 2011-08-01 10:36:37
    它还是一个将作业管理思想以及当今最新计算机技术完美统一起来,实现科学化和自动化管理的集成应用系统。 在功能方面,系统面向教学各个层次用户的需求,即教师和学生以及保障系统运行的系统管理员。为作业管理提供...
  • 自动化立体仓库机械设备一般包括高层货架、巷道堆垛机和出入库输送、搬运机械等。一、高层货架1、轻负载式高层货架轻负载式货架高度5~10m,以塑料篮等容器为存取单位,存取重量在50~100 kg,一般以重量轻、小的...
  • java springbootOA办公自动化系统(完整源码+sql可直接运行)主要功能模块:系统、用户、角色、考勤、流程、公告、邮件、任务、日程、计划、文件、笔记、通讯录、讨论区等多个模块管理 使用Maven进行项目管理,基于...
  • 在Ubuntu 14.04使用cron实现作业自动化

    万次阅读 2015-08-04 15:00:34
    在Ubuntu 14.04使用cron实现作业自动化作者:chszs,版权所有,未经同意,不得转载。博主主页:http://blog.csdn.net/chszsCron是Linux系统中最有用的工具之一,cron作业是在指定时间到来时被调度执行的作业。 最...
  • 嵌入式系统课程大作业设计报告

    千次阅读 2021-02-07 14:41:23
    嵌入式系统课程大作业设计报告 设计题目 基于Arm-Linux的嵌入式计数器设计 一、需求分析         1.根据系统功能,进行系统需求分析,设计嵌入式设备的软硬件总体方案,...
  • 基于AI的自动化处理

    千次阅读 2021-11-15 13:37:44
    采用自动化技术不仅可以把人从繁重的体力劳动、部分脑力劳动以及恶劣、危险的工作环境中解放出来,而且能扩展人的器官功能,极大地提高劳动生产率,增强人类认识世界和改造世界的能力。 ​ 一、游戏娱乐 ...
  • 作业管理系统设计报告

    千次阅读 2021-03-15 19:56:41
    目录 一、 引言(Introduction). 3 1. 背景(Background).... 2. 开发计划的目的....3. 项目开发参考资料(References...三、 计算机系统支持及开发环境. 7 1. 开发技术:. 7 2. 开发硬件. 7 3. 服务器环境. 7 4....
  • 2 相关技术介绍及系统环境开发条件 5 2.1相关技术介绍 5 2.2系统环境开发条件 6 3 系统的需求分析与设计 7 3.1可行性分析 7 3.2需求分析 7 3.2.1系统总体概述 8 3.2.2功能性需求 8 3.2.3非功能性需求 9 3.2.4流程图...
  • 硬件自动化测试浅谈

    千次阅读 2019-08-20 20:39:15
    硬件测试效率提升——研发过程中的硬件自动化测试 硬件自动化测试简述 提到自动化测试开发我们最先想到的都是针对代码的测试,使用现有的测试工具按照预先设定的场景对代码自动运行,发现代码中的bug,自动化测试...
  • 自动化控制系统是指能够实现自动控制任务的系统,由控制器与控制对象所组成。自动化控制系统的概念自动控制(automatic control)是指在没有人直接参与的情况下,利用外加的设备或装置,使机器、设备或生产过程的某个...
  • 作业管理系统设计报告_Struts2_设计报告

    千次阅读 多人点赞 2021-03-15 20:01:04
    目录 一、 引言(Introduction) 3 ...三、 计算机系统支持及开发环境 7 1. 开发技术: 7 2. 开发硬件 7 3. 服务器环境 7 4. 软件 7 四、 需求分析 8 1. 该系统的用例图 8 2. 结构图 13 .
  • 软件工程大作业自动售货机系统

    万次阅读 多人点赞 2020-04-04 21:26:48
    分析自动售货机系统的整个开发过程,包括需求分析、数据流图、数据字典、结构图和详细设计,通过分析,明白整个过程需要实现哪些功能,对数据有哪些要求,明确本系统的功能需求和性能需求,对系统的任务进行概述,...
  • 学生作业信息管理系统

    万次阅读 多人点赞 2018-06-23 00:36:18
        其次,答题信息管理系统可以大大提高老师与学生之间的在家庭作业和考核之间交流的效率,同时由于对题目以及学生成绩进行了数字,可以对学生成绩及老师教学效果进行大数据分析。     最...
  • 【Java】在Java中实现自动化脚本

    千次阅读 2021-03-10 16:15:47
    起因:最近在玩一款知名手游,日常任务较为机械繁琐,故想利用脚本来...利用Java自带的自动化测试类Robot,包为java.awt.Robot。 Robot中提供了许多用于自动化测试的方法: 2. Java获取鼠标指针的屏幕位置; 思路:.
  • 人体作业状态检测系统主要用于员工的身体状况进行提前检查综合分析判定员工作业状态是否符合作业公众要求通过筛选合适的作业工种人员有效管控生产安全提高生产效率 产品特点 1自动化自动监测自动生成报告 2智能化...
  • 企业运维自动化实战

    千人学习 2017-06-16 11:21:11
    内容涉及微博运维数据平台弹性集群资源管理及容器化实践、身份管理运维自动化系统构建之路、Elastic-Job-Cloud作业云在当当网SRE实践、集群管理自动化运维实践。随着云计算、大数据和人工智能等新兴技术的发展,如何...
  • 目前最主流的自动化测试技术selenium

    千次阅读 2021-08-05 09:45:04
    主流的自动化测试工具是QTP,现在已经淘汰。2014年左右selenium开始兴起。 自动化功能测试主要是用于提升测试人员工作效率,70%的工作时间都是在进行UI测试。全部都是基于前端界面来实现的交互性操作。尽可能实现...
  • 工业智能网关下工业自动化设备的远程监控方案,改变了工人的作业形式以及更加高效的设备维护效率和低成本,通过大本营中心连接上千万台的设备运营数据并统一管理,可实现大屏、手机端、PC电脑端以及更多的终端软件...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 117,895
精华内容 47,158
关键字:

自动化作业系统登录