import json

# loads 传入一个 JSON 格式的字符串，解码成 python 对象

data = '[{"姓名":"张三","年龄":"18"},{"姓名":"李四","年龄":"20"}]'

print(type(data))  #返回 & lt;class'str'>

new_data = json.loads(data)

print(new_data)

print(type(new_data))

with open('demo.json',encoding='utf8') as f1:

    #加载文件的对象

    py_list = json.load(f1)

    print(py_list)

    print(type(py_list))

data = '[{"姓名":"张三","年龄":"18"},{"姓名":"李四","年龄":"20"}]'

new_data = json.loads(data)

with open('title.json','w',encoding='utf8') as f2:

    # ensure_ascii=False 才能输入中文，否则是 Unicode 字符

    # indent=2 JSON 数据的缩进，美观

    json.dump(new_data,f2,ensure_ascii=False,indent=2)

data = '[{"姓名":"张三","年龄":"18"},{"姓名":"李四","年龄":"20"}]'

new_data = json.loads(data)

with open('title.json','w',encoding='utf8') as f2:

    # ensure_ascii=False 才能输入中文，否则是 Unicode 字符

    # indent=2 JSON 数据的缩进，美观

    json.dump(new_data,f2,ensure_ascii=False,indent=2)

import json

# 需要保存的数据有：

# 仓库系列 (2)：仓库长度 (length)、仓库宽度 (weight)

# 货架系列 (2)：货架数量 (n_pod)、货架容量限制 (pod_limitation)、货架位置 (loc_pod)、拣货口位置（loc_station）

# 机器人系列 (4)：机器人数量 (n_robot)、机器人空载与负载速度比 (ratio_T)、机器人到达货架时间 (Tp、Td)

# 商品系列 (3)：商品类型数量 (n_commodity_type)、每种商品总数量 (commodity_limitation)、货架 i 上包含商品 c 的数量 (A)

# 订单系列 (3)：商品总需求量 (total_order)、订单数量 (n_order)、订单 i 中包含商品 c 的数量 (B)

# 拣货系列 (1)：拣取一个商品所需时间 (Th)

'''读取json文件'''

with open('datas/6p_2r.json', 'r', encoding='utf8') as fp:

    # ensure_ascii=False 才能输入中文，否则是 Unicode 字符

    # indent=2 JSON 数据的缩进，美观

    json_datas = json.load(fp)

fp.close()

for i in range(len(json_datas)):

    length, weight = json_datas[i]['length'], json_datas[i]['weight']

    n_pod, pod_limitation, loc_pod, loc_station = json_datas[i]['n_pod'], json_datas[i]['pod_limitation'], json_datas[i]['loc_pod'], \

        json_datas[i]['loc_station']

    n_robot, ratio_T, Tp, Td = json_datas[i]['n_robot'], json_datas[i]['ratio_T'], json_datas[i]['Tp'], json_datas[i]['Td']

    n_commodity_type, commodity_limitation, A = json_datas[i]['n_commodity_type'], json_datas[i]['commodity_limitation'], json_datas[i]['A']

    total_order, n_order, B = json_datas[i]['total_order'], json_datas[i]['n_order'], json_datas[i]['B']

    Th = json_datas[i]['Th']

    print('The ' + str(i + 1) + 'th element of json file is successfully read')

import json

import random

from parameter import *

import numpy as np

# 功能：以轮盘赌的方式选取选中的商品

# 输入参数：剩余商品数组，随机数

# 输出参数：选中的商品类型

def get_selected_commodity(array, number):

    array_sum = 0

    selected_index = -1

    for i in range(len(array)):

        if array_sum < number <= array_sum + array[i]:

            selected_index = i

            break

        else:

            array_sum += array[i]

    return selected_index

# 功能：随机选取货架来放置商品

# 输入参数：货架状态数组

# 输出参数：选中的货架

def get_selected_pod(array):

    random_index = random.randint(0, len(array) - 1)

    while True:

        if array[random_index] == 3:

            random_index = random.randint(0, len(array) - 1)

        else:

            return random_index

# 函数功能：根据输入参数设计仓库布局（货架位置）

# 输出参数：机器人行走到每个货架所需时间（空载与负载）

def g_pod():

    if length * weight < n_pod:

        # 仓库布局违法

        raise Exception("仓库布局违法")

    else:

        Tp, Td = [], []

        loc = []  # 记录每个货架的位置

        mark_numbers = list(range(length * weight))  # 记录每个位置的编号

        random.shuffle(mark_numbers)  # 随机打乱所有编号后取前 n 个作为货架位置

        for i in range(n_pod):

            Tp.append(c_tp(mark_numbers[i]))

            Td.append(ratio_T * c_tp(mark_numbers[i]))

            loc.append(g_loc(mark_numbers[i]))

        # print ("每个货架的位置为：", loc)

        # print ("拣货站台的位置为：", [(weight - 1) / 2, length])

        return Tp, Td, loc, [(weight - 1) / 2, length]

# 函数功能：计算 Tp

# 输入参数：仓库长度，仓库宽度，货架位置记号

# 输出参数：机器人空载到达货架位置所需时间 Tp

def c_tp(mark_number):

    terminus = [(weight - 1) / 2, length]

    x, y = g_loc(mark_number)

    return abs(x - terminus[0]) + abs(y - terminus[1])

# 函数功能：根据标记获取货架位置

# 输入参数：仓库长度，货架位置记号

# 输出参数：货架位置（x, y）

def g_loc(mark_number):

    x = mark_number // length

    y = mark_number % length

    return x, y

if __name__ == '__main__':

    '''检测布局是否合法'''

    if n_pod > length * weight:

        raise Exception("****货架数量与仓库布局不匹配****")

    if not (pod_limitation[0] < sum(commodity_limitation) / n_pod < pod_limitation[1]):

        raise Exception("总商品存货数量与货架数量不匹配")

    if total_order < n_order or total_order > sum(commodity_limitation):

        raise Exception("订单数量与订单总需求商品不匹配")

    json_datas = []  # json 字符串格式变量，用来保存生成数据

    for n_data in range(n_datas):

        '''生成货架分布'''

        Tp, Td, loc_pod, loc_station = g_pod()  # 生成仓库布局

        # Tp, Td = np.array(Tp), np.array(Td)

        # print(Tp.tolist(), sep=',')

        # print(Td.tolist(), sep=',')

        '''生成商品分布'''

        commodities_distribution = np.zeros((n_pod, n_commodity_type), dtype=int)  # 存储货架上商品数量

        remain_commodity = commodity_limitation[:]  # 剩余商品

        remain_commodity_sum = sum(remain_commodity)  # noqa, 剩余商品汇总

        pod_commodity_sum = [0] * n_pod

        pod_state = [0] * n_pod  # 货架存货状态，0 表示还未到达最小容量，1 表示达到最小容量，2 表示在最小容量及最大容量之间，3 表示已经达到最大容量

        # 首先保证每个货架都满足最低限制

        for i in range(n_pod):

            selected_pod = i

            for _ in range(pod_limitation[0]):

                random_number = random.randint(1, remain_commodity_sum)

                selected_commodity = get_selected_commodity(remain_commodity, random_number)

                commodities_distribution[selected_pod, selected_commodity] += 1

                remain_commodity[selected_commodity] -= 1

                remain_commodity_sum = sum(remain_commodity)

                pod_commodity_sum[selected_pod] += 1

                pod_state[selected_pod] = 0 if pod_commodity_sum[selected_pod] < pod_limitation[0] else (

                    1 if pod_commodity_sum[selected_pod] == pod_limitation[0] else (

                        2 if pod_commodity_sum[selected_pod] < pod_limitation[1] else 3))

        while remain_commodity_sum != 0:

            selected_pod = get_selected_pod(pod_state)

            random_number = random.randint(1, remain_commodity_sum)

            selected_commodity = get_selected_commodity(remain_commodity, random_number)

            commodities_distribution[selected_pod, selected_commodity] += 1

            remain_commodity[selected_commodity] -= 1

            remain_commodity_sum = sum(remain_commodity)

            pod_commodity_sum[selected_pod] += 1

            pod_state[selected_pod] = 0 if pod_commodity_sum[selected_pod] < pod_limitation[0] else (

                1 if pod_commodity_sum[selected_pod] == pod_limitation[0] else (

                    2 if pod_commodity_sum[selected_pod] < pod_limitation[1] else 3))

        # print(commodities_distribution.tolist(), sep=',')

        '''生成订单分布'''

        orders = np.zeros((n_order, n_commodity_type), dtype=int)  # 订单 o 中商品 c 的数量

        remain_commodity = commodity_limitation[:]  # 剩余商品

        remain_commodity_sum = sum(remain_commodity)  # 剩余商品汇总

        remain_order = total_order  # 剩余订单需求商品数量

        for i in range(n_order):

            selected_order = i

            random_number = random.randint(1, remain_commodity_sum)

            selected_commodity = get_selected_commodity(remain_commodity, random_number)

            orders[selected_order, selected_commodity] += 1

            remain_commodity[selected_commodity] -= 1

            remain_commodity_sum = sum(remain_commodity)

            remain_order -= 1

        while remain_order != 0:

            selected_order = random.randint(0, n_order - 1)

            random_number = random.randint(1, remain_commodity_sum)

            selected_commodity = get_selected_commodity(remain_commodity, random_number)

            orders[selected_order, selected_commodity] += 1

            remain_commodity[selected_commodity] -= 1

            remain_commodity_sum = sum(remain_commodity)

            remain_order -= 1

        # print ("随机生成订单矩阵为：")

        # print(orders.tolist(), sep=',')

        '''生成json格式数据'''

        # 需要保存的数据有：

        # 仓库系列 (2)：仓库长度 (length)、仓库宽度 (weight)

        # 货架系列 (2)：货架数量 (n_pod)、货架容量限制 (pod_limitation)、 货架位置 (loc_pod)、拣货口位置（loc_station）

        # 机器人系列 (4)：机器人数量 (n_robot)、机器人空载与负载速度比 (ratio_T)、机器人到达货架时间 (Tp、Td)

        # 商品系列 (3)：商品类型数量 (n_commodity_type)、每种商品总数量 (commodity_limitation)、货架 i 上包含商品 c 的数量 (A)

        # 订单系列 (3)：商品总需求量 (total_order)、订单数量 (n_order)、订单 i 中包含商品 c 的数量 (B)

        # 拣货系列 (1)：拣取一个商品所需时间 (Th)

        json_data = {'length': length, 'weight': weight, 'n_pod': n_pod, 'pod_limitation': pod_limitation, 'loc_pod': loc_pod,

                     'loc_station': loc_station, 'n_robot': n_robot, 'ratio_T': ratio_T, 'Tp': Tp, 'Td': Td,

                     'n_commodity_type': n_commodity_type, 'commodity_limitation': commodity_limitation,

                     'A': commodities_distribution.tolist(), 'total_order': total_order, 'n_order': n_order, 'B': orders.tolist(), 'Th': Th}

        json_datas.append(json_data)

    '''生成json文件'''

    with open('datas/' + str(n_pod) + 'p_' + str(n_robot) + 'r_' + str(n_datas) + '.json', 'w', encoding='utf8') as fp:

        # ensure_ascii=False 才能输入中文，否则是 Unicode 字符

        # indent=2 JSON 数据的缩进，美观

        json.dump(json_datas, fp, ensure_ascii=False, indent=2)

    fp.close()

    print('json file \'' + str(n_pod) + 'p_' + str(n_robot) + 'r_' + str(n_datas) + '.json\'' + ' generates succeed')