项目记录（一）

项目来源不便细说，在此仅作留档使用，详细数据文件并不贴出。

1. Base_file.py`
   基础调用文件， 汇总实际数据处理的代码包，集成一体，即使添加新的模块也很轻松， 后期考虑添加多线程

import json
import os
import time
import numpy as np
import pandas as pd
from get_path import getPath
from open_json import OpenFile
from myencode import MyEncoder
from jsonDataGet import get_data
from FCW_AEB import FcwAeb
from ILC import ILC
if __name__ == "__main__":
	# 数据文件存储路径，留空
    base_floder_path = r''
    json_data_list = get_data(base_floder_path)
    # with open('./new_file.json', 'w', encoding='utf-8') as f:
    #     json.dump(json_data_list, f, cls=MyEncoder, ensure_ascii=False)
    while True:
        try:
            json_data = json_data_list.pop()
        except IndexError:
            break
        else:
            for key,value in json_data.items():
                '''
                将单个文件中的单条信息放入其中进行获取
                '''
                fa = FcwAeb(value)
                alert_warning_df = fa.alert_warning()
                approaching_warning_df = fa.approaching_warning()
                short_brake_df = fa.short_brake()
                prefill_df = fa.prefill()
                AEB_df = fa.AEB()
                EBA_df = fa.EBA()
                AEB_pedestrian_df = fa.AEB_pedestrian()
                AEB_two_wheeled_vehicle_df = fa.AEB_two_wheeled_vehicle()
                ilc = ILC(value)
                ilc.Transition_to_Take_Over_Request()
                ilc.ILC_to_seven()

2. get_path.py
   简单的文件路径搜寻函数

import os

def getPath(path):
    '''
    parms: {path} Base path address
    '''
    file_list = []
    for root,dirs,files in os.walk(path):
        for i in files:
            if i.endswith('json'):
                file_list.append(os.path.join(root,i))
    return file_list

3. jsonDataGet.py
   json数据文件粗处理函数， 用于进行数据反转排序。
   这里使用的数据文件本身是断断续续的数据，每一小段最大十个，最小甚至没有，时间戳一段数据共用一个，所以需要进行一下初步的处理

import json
import os
import time
import numpy as np
import pandas as pd
from get_path import getPath
from open_json import OpenFile
from myencode import MyEncoder
def get_signal_list():
    signal = input('请输入要获取的信号（多个信号以“,”分隔）：')
    print('要获取的信号为：', signal if signal else '无信号。')
    if signal != '':
        if ',' in signal:
            signal_list = signal.split(',')
        else:
            signal_list.append(signal)
def get_data(path):
    file_list = getPath(path)
    signal_list = []
    get_signal_list()
    json_file_data_list = []
    while True:
        try:
            file_path = file_list.pop()
        except IndexError as e:
            break
        else:
            file_name = file_path.split('\\')[-1].split('.')[0]
            print(file_name,'读取ing')
            of = OpenFile(file_path)
            json_file_data = of.data_analysis(signal_list=signal_list)
            if json_file_data:
                json_file_data_list.append(json_file_data)
        # break
    return json_file_data_list

4. myencode.py
   json文件持久化存储时需要确保编码顺利， 通过构建函数来进行数据类型修改， 防止因为数据类型问题导致数据保存失败

import json
import numpy
class MyEncoder(json.JSONEncoder):
    def default(self, obj):
        try:
            if isinstance(obj, bytes):
                return str(obj, encoding='utf-8')
            if isinstance(obj, (numpy.int_, numpy.intc, numpy.intp, numpy.int8,numpy.int16, numpy.int32, numpy.int64, numpy.uint8,numpy.uint16,numpy.uint32, numpy.uint64)):
                return int(obj)
            elif isinstance(obj, (numpy.float_, numpy.float16, numpy.float32,numpy.float64)):
                return float(obj)
            elif isinstance(obj, (numpy.ndarray,)): # add this line
                return obj.tolist() # add this line
            return json.JSONEncoder.default(self, obj)
        except UnicodeDecodeError:
            pass

5. open_json.py
   用于读取json文件并返回数据流

import json
import numpy as np
import pandas as pd

class OpenFile:
    def __init__(self, path):
        self.data = self.open_file(path)
    def open_file(self, path):
        try:
            f = open(path, 'r', encoding='utf8').read()
            if f:
                json_data = json.loads(f)
        except Exception as e:
            return False
        else:
            return json_data
    def data_analysis(self, signal_list=None):
        if self.data:
            value_data_list = []
            for key,value in self.data.items():
                keyId = value['keyId']
                sampleTime = value['sampleTime']
                if signal_list:
                    dataList = {}
                    while True:
                        try:
                            signal = signal_list.pop()
                        except IndexError as e:
                            break
                        else:
                            dataList[signal] = value['dataList'][signal]
                else:
                    dataList = value['dataList']
                value_data_list.append({
                    'keyId': keyId,
                    'sampleTime': sampleTime,
                    'dataList': dataList
                })
            value_data_list = sorted(value_data_list,key=lambda keys: keys['keyId'])
            
            data_list = {}
            for i in value_data_list:
                if i['keyId'] not in data_list.keys():
                    data_list[i['keyId']] = []
                data_list[i['keyId']].append({'sampleTime':i['sampleTime'], 'dataList': i['dataList']})
            for key, value in data_list.items():
                data_list[key] = sorted(value, key=lambda keys: keys['sampleTime'])
            return data_list
        else:
            print('文件开启失败')
            return False

6. functions
   这部分是最麻烦的详细数据处理， 前两个函数为通用函数，之后便是重复性的条件判断书写，逻辑设计， 具体不方便写出来， 而且本身这个也是具有强烈的针对性， 本文章只是留个记录， 大家看了或许能给自己带来点灵感，所以这里就不写详细的项目判断逻辑了

import numpy as np
import pandas as pd

class FcwAeb:
    def __init__(self, data):
        self.data = data
    # 数据精细处理函数（通用型）
    def data_analysis(self, signal_list):
        all_sampleTime = []
        all_data = {}
        for this_value in self.data:
            sampleTime = [int(this_value['sampleTime']) - 1000*i for i in range(10)]
            sampleTime.reverse()
            all_sampleTime.extend(sampleTime)
            for key in signal_list:
                if key in this_value['dataList']:
                    data = this_value['dataList'][key]
                    if data == '':
                        data = [0 for i in range(10)]
                    elif 1 < len(data) < 10:
                        if ',' not in data:
                            data = [data] + [0 for i in range(9)]
                        else:
                            data = data.split(',') + [0 for i in range(10-len(data))]
                    else:
                        data = data.split(',')
                else:
                    continue
                data.reverse()
                if key in all_data:
                    all_data[key].extend(data)
                else:
                    all_data[key] = data
        return (all_sampleTime, all_data)
    # 矩阵构建函数
    def create_DataFrame(self, data, Isolation_list):
        sample_data = {}
        for key in data.keys():
            sample_data[key] = data[key]['samples']
        index_list = []
        index_num = 0
        print('开始构建DataFrame')
        data_len = []
        key_list = []
        for key,value in sample_data.items():
            data_len.append(len(value))
            key_list.append(key)
        for i in range(len(data_len)):
            if data_len[i] < max(data_len):
                sample_data[key_list[i]].extend([0 for j in range(max(data_len)-data_len[i])])
        this_data = pd.DataFrame(sample_data)
        message_list = []
        columns_list = list(this_data)
        print('开始计算单一时间的状态')
        for indexs in this_data.index:
            # 单行数据转化列表
            one_result = []
            one_data = this_data.loc[indexs].values.tolist()
            for i in range(len(one_data)):
                if i not in Isolation_list:
                    if one_data[i] == 0:
                        pass
                    else:
                        for key,value in data[columns_list[i]]['condition'].items():
                            if one_data[i] == value:
                                one_result.append(columns_list[i] + ': ' + key)
                                break
                else:
                    if one_data[i] == 1:
                        pass
                    else:
                        for key,value in data[columns_list[i]]['condition'].items():
                            if one_data[i] == value:
                                one_result.append(columns_list[i] + ': ' + key)
                                break
            if one_result == []:
                message = '功能运行正常。'
            else:
                message = ';'.join(one_result)
            message_list.append(message)
        this_data['Final_result'] = message_list
        return this_data
    def alert_warning(self):
        timestamps, datalist = self.data_analysis(a)
        result = {
            # 1 目标状态
            'IFC_AEBTarMotionState': {'samples': [], 'timestamps': [], 'condition':{'Stationary': 1, 'Moving': 2}},
            # 2 车速范围
            'BCS_VehSpd': {'samples': [], 'timestamps': [], 'condition':{'Normal': 0, 'Out_of_range': 1}},
            # 3 报警触发间隔
            'MRR_FCWLatentWarn': {'samples': [], 'timestamps': [], 'condition':{'No_warning': 0, 'Warning': 1}},
            # 4 VDC
            'BCS_VDCActiveSt': {'samples': [], 'timestamps': [], 'condition':{'Not_active': 0, 'Active': 1}},
            # 5 TCS
            'BCS_TCSActiveSt': {'samples': [], 'timestamps': [], 'condition':{'Not_active': 0, 'Active': 1}},
            # 6 FCW
            'MRR_FCWOffSt': {'samples': [], 'timestamps': [], 'condition':{'On': 0, 'Off': 1}},
            # 7 发动机运转
            'VCU_VehRdySt': {'samples': [], 'timestamps': [], 'condition':{'Not_ready': 0, 'Ready': 1}},
            # 8
            'MRR_ACCActiveSt': {'samples': [], 'timestamps': [], 'condition':{'Not_active': 0, 'Active': 1}}
        }
        for key in result.keys():
            '''逻辑判断条件位置'''
        # 数据矩阵构建
        this_dataFrame = self.create_DataFrame(result, [0,5])
        return this_dataFrame

PS：以上内容来自于工作项目， 请勿直接套用，仅可用于参考。
附上个人小站：我的小站
转载挂载本文链接