A container loading system for logistics transportation based on algorithms and information technology

Abstract

This invention discloses a container loading system for logistics transportation based on algorithms and information technology. The system finds the optimal loading scheme through algorithms, specifically using combination algorithms, width algorithms, and delivery date algorithms. For pallets that need to be loaded, under limited constraints, the system finds the optimal loading scheme with the highest container utilization rate, thereby improving the utilization rate of container capacity space. Under the premise of not exceeding the weight limit of the destination port and the safe stacking of goods, the system loads as much goods as possible, thereby reducing the unit freight cost and avoiding the need for repeated manual trials and modifications to the loading scheme.

Description

Technical Field

[0001] This invention relates to the field of information technology, specifically to a container loading system for logistics transportation based on algorithms and information technology. Background Technology

[0002] While current container loading software systems on the market can solve some standard pallet loading planning problems, they cannot handle the challenges posed by home furnishing manufacturers shipping numerous goods to retailers, requiring the entire container to be disassembled into pallets of varying heights for assembly and loading. To address this issue, experienced loading planners currently rely on manually drawing two-dimensional loading diagrams to develop loading plans and then instructing forklift drivers to load the containers based on these simple diagrams and their experience. If the container is full and there are still pallets that cannot be loaded, the planner must be informed to revise the loading plan, which is extremely inconvenient. Summary of the Invention

[0003] In view of the shortcomings of existing technologies, the present invention aims to provide a logistics transportation container loading system based on algorithms and information technology.

[0004] To achieve the above objectives, the present invention adopts the following technical solution:

[0005] A logistics and transportation container loading system based on algorithms and information technology, including a front-end web business system and a back-end algorithm system;

[0006] The front-end web business system includes an order recording module, an order filtering module, a communication module, and a 3D graphics display module;

[0007] Order Record Module: Used to record order information placed by customers; the order information includes the shipping destination, order delivery time, and delivery status;

[0008] Order filtering module: This module allows packing and shipping planners to filter all pending orders destined for the same destination by the shipping destination and select the container type, boundary parameters, and safety parameters. Based on this, the order filtering module generates XML messages in the order of the filtered pending orders.

[0009] Communication module: Used to send the XML messages generated by the order filtering module to the backend algorithm system through a secure communication mechanism, and to receive the container loading suggestions calculated by the backend algorithm system;

[0010] 3D Graphics Display Module: Used to dynamically display the container loading suggestions obtained by the backend algorithm system in a 3D graphic format;

[0011] The backend algorithm system is used to calculate a container loading suggestion scheme that meets the container utilization requirements based on the XML message sent by the frontend Web business system. The container loading suggestion scheme includes the stacking method and stacking order of each commodity pallet, which can be represented in a three-dimensional graphical manner.

[0012] Furthermore, the aforementioned system also includes a data interface system; the data interface system is used to connect to a unified ERP business system, and the front-end Web business system can interact with the ERP business system through the data interface system.

[0013] Furthermore, the aforementioned system also includes a manual adjustment system. This manual adjustment system is used by container loading planners when they manually review the container loading suggestions provided by the background algorithm system. If they find that the container loading suggestions need to be adjusted, they can directly start the manual adjustment system to manually adjust the container loading suggestions when the front-end web business system displays the 3D graphics.

[0014] Furthermore, the algorithms run by the background algorithm system include quicksort algorithm, combination algorithm, width algorithm, multi-cabinet algorithm, and delivery date algorithm:

[0015] 1) Quicksort algorithm

[0016] Use a list to store the block elements, and id_list to store the corresponding index of the sorting block in the list element. The index data id_list corresponding to the data to be sorted in the list is initialized with indices from 0 to n. Select the first element in id_list, move all data with indices greater than or equal to the first element to the left, and move all data with indices less than the first element to the right. After the first split operation, two subsequences are formed with the current position of the first element as the split point. Repeat the same split operation on the two subsequences until all the split sequences have only one element.

[0017] 2) Combinatorial Algorithm:

[0018] Combinatorial algorithms address the heterogeneous bin packing problem. Based on block loading, they can generate placement schemes according to a specified loading sequence, incorporating constraints such as orientation reservation and stability limitations. Multiple bins form composite blocks, each containing one or more bins with varying orientations and a small number of empty spaces that do not affect loading. The specific process is as follows: The list of bins calculated by the quicksort algorithm is placed into `jc_list`. In the first iteration, the first element is combined with each element and concatenated. If successful, the newly generated element is appended to `jc_list`. In the second iteration, the newly added element is combined with each element in `jc_list` and concatenated. If successful, the newly generated element is appended to `jc_list`. This second iteration is repeated until no new elements are added or the number of elements reaches the maximum capacity of `jc_list`.

[0019] 3) The specific process of the width algorithm is as follows:

[0020] 3.1) Solve for width combinations for all pallets:

[0021] Assume the available width of the container is CT_WIDTH, and the pallet set is P = {P1, ..., Pn}. This set is a set of pallet types, and each pallet has 4 attributes: length, width, quantity, and rotation.

[0022] Get the width GetPalletWidth(p);

[0023] Get the number of pallets using GetPalletQty(p);

[0024] A width combination is W = {P1, ..., Pm}. Any two pallets in the width combination may be the same type of pallet or different types of pallets. Pallets of the same type may have the same orientation or different orientations.

[0025] Perform width combination operation:

[0026] Get the number of times a specific tray has been used: GetWidthComPalletQty(W, Pi)

[0027] WidthSelfJoin(W)

[0028] Therefore, the constraint formula is:

[0029] m<=n,

[0030] GetPalletWidth(P1)+…+GetPalletWidth(Pm)<=CT_WIDTH, GetWidthComPalletQty(W,Pi)<=GetPalletQty(Pi), i>=1,i<=m

[0031] 3.2) Sort the result set of width combinations in reverse order of width value;

[0032] 3.3) Calculate the optimal net volume packing result by performing different permutations and combinations from the width value sorting results:

[0033] Assume that the set of all width combinations is WP = {W1, ..., Wn}, a packing result is a permutation of several widths W, and the packing result is described as PK = {W1, ..., Wm}; the set of all packing results is described as PACKS = {PK1, ..., PKn}, and the width, height and length of the container are CT_XLEN, CT_YLEN, and CT_ZLEN respectively.

[0034] 3.3.1) Perform the comparison operation as follows:

[0035] 3.3.1.1) Get the list of pallets with coordinates for the packing results item_list = GetPkPalletItemList(PK), which is used for the subsequent acquisition of sub-compound blocks. It needs to be sorted by height to meet the safety requirement of front high and back low;

[0036] 3.3.1.2) Compare net volumes using GetPkNetVol(PK), which obtains the net volume of each packing result for subsequent calculations and comparisons, and records the result with the largest net volume;

[0037] 3.3.1.3) Compare the maximum width using GetPkMaxXLength(item_list), which retrieves the maximum width for comparison. The maximum width cannot exceed the container width.

[0038] 3.3.1.4) Compare the maximum height using GetPkMaxYLength(item_list), which retrieves the maximum height and is used to ensure that the maximum height does not exceed the container height;

[0039] 3.3.1.5) Compare the maximum length GetPkMaxZLength(item_list), which is used to obtain the maximum length and is used to compare the length of the container.

[0040] 3.3.1.6) Compare the number of pallets using GetPkPalletQty(item_list,Pi), which retrieves the number of pallets. The calculation ends when all pallets have been filled.

[0041] The constraints for comparison operations are:

[0042] 1) Any Wi belongs to WP;

[0043] 2)GetPkMaxXLength(item_list)<=CT_XLEN;

[0044] 3)GetPkMaxYLength(item_list)<=CT_YLEN;

[0045] 4)GetPkMaxZLength(item_list)<=CT_ZLEN;

[0046] 5)GetPkPalletQty(item_list,Pi)<=GetPalletQty(Pi)

[0047] 6) No two trays can intersect;

[0048] 3.3.2) Execute the connection operation WidthNodeJoin(Wi,Wj);

[0049] 3.3.3) The formula for calculating the net volume of the packing is as follows:

[0050] MaxPkNetVol = PKx, where PKx belongs to the set PACKS and PKx has the largest net volume;

[0051] 3.3.4) The following calculations are performed based on the breadth-first PK tree search algorithm:

[0052] (1) Select the pallet Pi to be loaded;

[0053] (2) Select the width combination containing the Pi tray from the set WP, and the width W1 is the largest;

[0054] (3) Perform a self-join operation WidthSelfJoin(W1) on W1.

[0055] (4) Select the next depth W2 and perform the connection operation WidthNodeJoin(Wi,Wj). If the connection is successful and all constraints are satisfied;

[0056] (5) Repeat step (4) until no width that meets the condition can be found, then a packing result PK is generated;

[0057] (6) For PK={W1,…,Wm}, perform a width search on the last layer Wm. Start the search from the next element of Wm in the width sorting results. There is no limit to the depth, but the width is limited to a fixed value of 10. This value is fixed and can be adjusted.

[0058] (7) The general principle is that if the tree can go down, it will go down; if it cannot go down, it will go right; if it cannot go right, it will go up. At this time, the last element Wm of the result PK will go right. If it can be found, it will go down; otherwise, it will go up.

[0059] (8) This will generate a search tree, and the path from the root node to each leaf node is a boxed result PK; the set of all paths from the root node to the leaf node is PACKS;

[0060] 3.4) High-performance parallel computing programming technology is used to select the overall optimal container loading scheme from feasible width combinations; by searching only feasible width combinations, the amount of computation is reduced exponentially.

[0061] 4) The specific process of the multi-cabinet algorithm is as follows:

[0062] 4.1) Match the heights of the pallets to determine if the heights are compatible;

[0063] The pallets are matched by height using a combination algorithm. If the pallets are stacked in the Y direction and the height is less than 80% of the container height, then the height is difficult to match; otherwise, it is easy to match. Assuming the operation is GetPalletYMatch(P), it returns 1 for difficult matching and 0 otherwise.

[0064] 4.2) Match the width of the pallet to determine if the width is easy to match;

[0065] Width Matching: If the pallet is self-matched in the X direction, it can be rotated. If the sum of the widths is less than 94% of the container width, then the width is difficult to match; otherwise, it is easy to match. Assuming the operation is GetPalletXMatch(P), it returns 1 for difficult matching and 0 otherwise. GetPalletXMatchGap(P) represents the remaining gap after the pallet width is self-matched.

[0066] 4.3) Based on steps 4.1) and 4.2), calculate the matching difficulty value and sort all pallets by difficulty.

[0067] The formula for calculating pallet priority is:

[0068] Priority(P)=10000*GetPalletYMatch(P)+1000*GetPalletXMatch(P)+GetPalletXMatchGap(P) / 10;

[0069] 4.4) Select the optimal width combination for each pallet in sequence and connect them, and record the result of the maximum net volume loading MaxNetVol(PACKS): get the net volume for each PK in the set PACKS, traverse the set and return the maximum net volume;

[0070] The search termination conditions include: each tray search lasts a maximum of 2 minutes, reaches the preset utilization rate, and is fully loaded;

[0071] Repeat step 4.4) until all pallets are loaded;

[0072] 5) The specific process of the delivery time algorithm is as follows:

[0073] 5.1) Determine the required pallet quantity; the quantity of orders with the current delivery date is the required quantity.

[0074] 5.2) Load all pallets with a quantity greater than 0 first;

[0075] 5.3) If the number of pallets within the current delivery period is insufficient to fill a container, an order for the quantity outside the current delivery period can be placed.

[0076] The beneficial effects of this invention are as follows:

[0077] 1) This invention finds the optimal container loading scheme through algorithms, specifically using combination algorithms, width algorithms, and delivery date algorithms. For pallets that need to be loaded into containers, under limited constraints, the optimal container loading scheme with the highest container utilization rate is obtained, thereby improving the utilization rate of container capacity space and loading as much cargo as possible without exceeding the weight limit of the destination port and ensuring safe stacking of goods, thereby reducing the unit freight cost and avoiding the need for repeated manual trials and modifications to the container loading scheme.

[0078] 2) This invention can effectively reduce the experience requirements and workload of container loading planners and operators. The application of this invention can standardize the container loading process, using a software system to solidify the experience of experienced container loading planners and operators. This allows them to achieve the experience of container loading planners with over 5 years of experience after simple computer software training. It also significantly reduces the workload of experienced container loading planners in manually drawing diagrams, thus reducing the number of planners required. For container loading operators, it can provide a 3D graphical display to show the loading steps, following the system-simulated container stacking order, avoiding situations where there is not enough space and the container loading plan needs to be modified.

[0079] 3) This invention solves the "pallet splitting" filling problem that existing container loading systems and algorithms do not support. The "pallet splitting" scheme supported by this invention can involve breaking down a whole pallet of goods into n equal-height "1 / n pallets" or m pallets of unequal height. These shorter pallets are used for top filling. Furthermore, the n or m pallets resulting from the splitting of a whole pallet of goods must be shipped within a single container, not scattered across different containers, to ensure the integrity of orders delivered as a whole pallet. Solving this problem not only improves container space utilization based on existing pallet splitting schemes but also continuously assists users in developing new pallet splitting schemes, further enhancing container space utilization. Attached Figure Description

[0080] Figure 1 This is a schematic diagram of the system composition in an embodiment of the present invention;

[0081] Figure 2 This is a flowchart illustrating the implementation of the quicksort algorithm in an embodiment of the present invention.

[0082] Figure 3 This is a flowchart illustrating the implementation of the combination algorithm in an embodiment of the present invention. Detailed Implementation

[0083] The present invention will be further described below with reference to the accompanying drawings. It should be noted that this embodiment is based on the present technical solution and provides detailed implementation methods and specific operation processes, but the protection scope of the present invention is not limited to this embodiment.

[0084] This embodiment provides a logistics transportation container loading system based on algorithms and information technology, including a front-end web business system and a back-end algorithm system;

[0085] The front-end web business system includes an order recording module, an order filtering module, a communication module, and a 3D graphics display module;

[0086] Order Record Module: Used to record order information placed by customers; the order information includes the shipping destination, order delivery time, and delivery status (pending delivery or delivered);

[0087] Order Filtering Module: This module allows packing and shipping planners to filter all pending orders destined for the same destination, and to set container type, boundary parameters, and safety parameters. The module sorts the filtered pending orders by delivery time and generates an XML message along with the set container type, boundary parameters, and safety parameters.

[0088] It should be noted that the boundary parameters include:

[0089] Maximum clearance value: refers to the maximum length of unloaded space remaining at the rear of the container;

[0090] Length tolerance: Some containers may be longer than standard containers, or a gap may be required at the rear. This difference in length or the length of the gap is called the length tolerance.

[0091] Width tolerance: Some containers require a gap on the left and right sides, and the width of this gap is the width tolerance;

[0092] Height tolerance: A gap must be left at the top of some containers; the height of this gap is the height tolerance.

[0093] Beam height: refers to the height of the beam at the rear of the container, directly above the cabinet door;

[0094] Beam width: refers to the width of the beam directly above the rear of the container;

[0095] Corner fitting length, width, and height: refers to the length, width, and height of the rectangular iron blocks at the top of the left and right sides at the innermost part of the container.

[0096] Safety parameters include:

[0097] Anti-tilt boundary value: refers to the maximum value of the difference in length or width between the upper pallet and the lower pallet when the upper pallet is larger than the lower pallet;

[0098] Load-bearing capacity verification: The pallet has load-bearing parameters, and the weight of the pallet placed on top must not exceed the load-bearing capacity;

[0099] Anti-door collapse check: Should the pallet at the rear of the container near the door be considered for anti-door collapse?

[0100] Honeycomb panel activation indicator: This indicates whether honeycomb panels are required when configuring and loading the container;

[0101] Honeycomb panel height: refers to the height of the honeycomb panel;

[0102] Honeycomb panel boundary value: refers to the difference in length or width between the upper pallet and the lower pallet (honeycomb panels are placed outside this value).

[0103] Packing and shipping planners can set the above boundary and safety parameters.

[0104] Communication module: Used to send the XML messages generated by the order filtering module to the backend algorithm system through a secure communication mechanism, and to receive the container loading plan calculated by the backend algorithm system;

[0105] The 3D graphics display module dynamically displays the container loading suggestions calculated by the backend algorithm system in 3D graphics. This facilitates manual review and approval of the container loading suggestions by the loading planners.

[0106] The backend algorithm system is used to calculate a container loading suggestion scheme that meets the container utilization requirements based on the XML message sent by the frontend Web business system. The container loading suggestion scheme includes the stacking method and stacking order of each commodity pallet represented in a three-dimensional graphic.

[0107] In this embodiment, the logistics and transportation container loading system also includes a data interface system; the data interface system is used to connect to a unified ERP business system, and the front-end Web business system can interact with the ERP business system through the data interface system.

[0108] Furthermore, in this embodiment, the logistics and transportation container loading system also includes a manual adjustment system. The manual adjustment system is used by loading planners when they manually review the loading suggestions provided by the background algorithm system. If they find that the loading suggestions need to be modified (such as not taking into account certain special cases), the loading planners can directly start the manual adjustment system when the front-end web business system displays the 3D graphics and manually adjust the loading suggestions in the manual adjustment system so that the loading plan is strictly consistent with the user's actual situation and is more in line with the actual situation.

[0109] It should be noted that the backend algorithm system needs to be deployed on a separate multi-CPU parallel computing server environment, while the manually adjusted system and data interface system can be deployed on a regular server environment, such as... Figure 1 As shown.

[0110] The backend algorithm system employs parallel computing technology and a multi-threaded C / C++ programming language, enabling independent algorithm execution. This system must run on a dedicated multi-CPU computer server, supports iterative upgrades, and supports multiple algorithm implementations. However, it lacks a user-friendly interface and cannot be directly operated by non-developers. For inputting calculation parameters, it receives external instructions through the frontend web application system. It automatically selects different algorithms and constraints, as well as single-cabinet and multi-cabinet loading options, based on varying input parameters to improve the computational efficiency and convergence speed of the loading scheme, obtaining the optimal loading recommendation under finite constraints. The optimal loading recommendation is also fed back to the user through the frontend web application system.

[0111] It should be noted that the data interface system aims to improve customer experience and reduce the duplication of data entry across different systems. Utilizing electronic data interchange (EDI) technology, it enables automatic data transfer between different systems. These data interfaces typically include the import of order information between the front-end web business system and the ERP business system. The front-end web business system feeds back the approved container loading plan to the ERP business system for booking, and removes pending orders from the ERP business system's pending orders list, keeping the pending orders synchronized with the actual delivery status.

[0112] It should be noted that the manual adjustment system operates within a virtual reality (VR) environment. The system can be activated during 3D graphic display. It accepts all data from the proposed container loading plan and performs manual adjustments within the plan's coordinate system. Once the adjustments are satisfactory, the results are directly fed back to the 3D graphic display module of the front-end web business system, allowing for the programming of a revised container loading plan.

[0113] It should be noted that in this embodiment, the front-end web business system serves as the user interface, developed using the JAVA programming language and running in an internet environment. It features a rich selection of functions and a user interface, supporting operators in selecting single-container and multi-container loading calculations, choosing container types, maintaining and selecting container weight limits at destination ports, selecting the internal space of containers, maintaining and checking commodity load-bearing data, and maintaining and checking user loading experience parameters. The 3D graphics display module allows users to select and display 3D graphics of different loading suggestions, and allows for repeated display of the loading process and its effects by dragging the mouse. The front-end web business system can also import dynamic loading data, such as order information, from the ERP business system to the back-end algorithm system via a data interface system. After obtaining the results, the approval results of the loading suggestions are fed back to the ERP business system. Loading suggestions requiring manual adjustment can be directly imported into the manual adjustment system, and the manual adjustment VR subsystem's user interface can be activated.

[0114] Furthermore, in this embodiment, the algorithms run by the background algorithm system include quicksort, combination algorithm, width algorithm, multi-container algorithm, and delivery date algorithm. Each algorithm runs independently and can call the calculation results of other algorithms. Quicksort is the foundation, and its calculation results are used in other algorithms. The width algorithm can call the calculation results of quicksort, and it uses the width feature of containers to speed up convergence. The combination algorithm uses the calculation results of the width algorithm to generate a set of container combinations, and selects the combination with the largest net volume from the set. If there are orders that must be shipped, the combination algorithm calls the calculation results of the width algorithm and the delivery date algorithm at the same time to ensure that orders within the delivery date are shipped first. The multi-container algorithm is used to generate multiple container loading results by repeatedly calling the combination algorithm according to the priority of the pallets to be shipped when more than two containers can be filled.

[0115] 1) Quicksort algorithm

[0116] This embodiment improves the single-CPU quicksort algorithm to a quicksort algorithm that supports parallel computing across multiple CPU cores. `list` stores the block elements, and `id_list` stores the corresponding indices of the sorted blocks within the elements of `list`. The quicksort algorithm flow is described as follows: Figure 2 As shown. The index data `id_list` corresponding to the data `list` to be sorted is initialized with indices from 0 to n. The first element of `id_list` is selected, and all data with indices greater than or equal to the first element are moved to the left, while all data with indices less than the first element are moved to the right. After the first split operation, two subsequences are formed, with the current position of the first element as the dividing point. The same split operation is repeated on both subsequences until all split sequences contain only one element. The corresponding algorithm statements are as follows:

[0117] Assuming the tray list is a list, id_list stores the index of the sorting block in the list element, i_left = 0, i_right = len(list), key is the width of the first element of the list, and used is the number of times the algorithm is executed.

[0118]

[0119]

[0120] 2) Combinatorial Algorithm:

[0121] Combinatorial algorithms address the heterogeneous bin packing problem (containing multiple types of bins). Based on block loading, they generate placement schemes according to a specified loading sequence, incorporating constraints such as orientation reservation and stability limitations. Multiple bins form composite blocks, each containing one or more types of bins with varying orientations and a small number of empty spaces that do not affect loading. Composite blocks increase the number of selectable blocks and the sum of the bin volumes in each loading operation, accelerating loading and significantly improving algorithm efficiency. The flow of the combinatorial algorithm based on composite blocks is described below. Figure 3 As shown. The tray list calculated by the quicksort algorithm is placed into jc_list. In the first loop, the first element is combined with each element in the existing jc_list and concatenated. If successful, the newly generated element is appended to jc_list. In the second loop, the newly added element is combined with each element in jc_list and concatenated. If successful, the newly generated element is appended to jc_list. The second loop is repeated until no new elements are added or the number of elements reaches the maximum capacity of jc_list. The corresponding algorithm statements for the above process are as follows:

[0122]

[0123]

[0124] 3) Width Algorithm

[0125] To achieve high overall container utilization, high container width utilization is essential. However, high local width utilization does not necessarily lead to high overall utilization. This is because the number of easily matched pallets is limited. Once these are used, less versatile pallets leave more empty space, resulting in low overall space utilization. How to improve container width utilization, and how to meet safety requirements when combining different widths to ensure pallets have support both front and back, are key questions. The specific process of the width algorithm is as follows:

[0126] 3.1) Solve for width combinations for all pallets:

[0127] Assume the available width of the container is CT_WIDTH, and the pallet set is P = {P1, ..., Pn}. This set is a set of pallet types, and each pallet has 4 attributes: length, width, quantity, and rotation.

[0128] Get the width GetPalletWidth(p);

[0129] Get the number of pallets using GetPalletQty(p);

[0130] A width combination is W = {P1, ..., Pm}. Any two pallets in the width combination may be the same type of pallet or different types of pallets. Pallets of the same type may have the same orientation or different orientations.

[0131] Perform width combination operation:

[0132] Get the number of times a specific tray has been used: GetWidthComPalletQty(W, Pi)

[0133] WidthSelfJoin(W)

[0134] Therefore, the constraint formula is:

[0135] m<=n,

[0136] GetPalletWidth(P1)+…+GetPalletWidth(Pm)<=CT_WIDTH, GetWidthComPalletQty(W,Pi)<=GetPalletQty(Pi), i>=1,i<=m

[0137] 3.2) Sort the result set of width combinations in reverse order of width value;

[0138] 3.3) Calculate the optimal net volume packing result by performing different permutations and combinations from the width value sorting results:

[0139] Assume the set of all width combinations is WP = {W1, ..., Wn}, and a packing result is a permutation of several widths W, described as PK = {W1, ..., Wm}. The set of all packing results is described as PACKS = {PK1, ..., PKn}, and the width, height, and length of the container are CT_XLEN, CT_YLEN, and CT_ZLEN, respectively.

[0140] 3.3.1) Perform the comparison operation as follows:

[0141] 3.3.1.1) Get the list of pallets with coordinates for the packing results item_list = GetPkPalletItemList(PK), which is used for the subsequent acquisition of sub-compound blocks. It needs to be sorted by height to meet the safety requirement of front high and back low;

[0142] 3.3.1.2) Compare net volumes using GetPkNetVol(PK), which obtains the net volume of each packing result for subsequent calculations and comparisons, and records the result with the largest net volume;

[0143] 3.3.1.3) Compare the maximum width using GetPkMaxXLength(item_list), which retrieves the maximum width for comparison. The maximum width cannot exceed the container width.

[0144] 3.3.1.4) Compare the maximum height using GetPkMaxYLength(item_list), which retrieves the maximum height and is used to ensure that the maximum height does not exceed the container height;

[0145] 3.3.1.5) Compare the maximum length GetPkMaxZLength(item_list), which is used to obtain the maximum length and is used to compare the length of the container.

[0146] 3.3.1.6) Compare the number of pallets using GetPkPalletQty(item_list,Pi), which retrieves the number of pallets. The calculation ends when all pallets have been filled.

[0147] The constraints for comparison operations are:

[0148] 1) Any Wi belongs to WP;

[0149] 2)GetPkMaxXLength(item_list)<=CT_XLEN;

[0150] 3)GetPkMaxYLength(item_list)<=CT_YLEN;

[0151] 4)GetPkMaxZLength(item_list)<=CT_ZLEN;

[0152] 5)GetPkPalletQty(item_list,Pi)<=GetPalletQty(Pi)

[0153] 6) No two trays can intersect.

[0154] 3.3.2) Execute the connection operation WidthNodeJoin(Wi,Wj)

[0155] 3.3.3) The formula for calculating the net volume of the packing is as follows:

[0156] MaxPkNetVol = PKx, where PKx belongs to the set PACKS and PKx has the largest net volume;

[0157] 3.3.4) The following calculations are performed based on the breadth-first PK tree search algorithm:

[0158] (1) Select the pallet Pi to be loaded;

[0159] (2) Select the width combination containing the Pi tray from the set WP, and the width W1 is the largest;

[0160] (3) Perform a self-join operation WidthSelfJoin(W1) on W1.

[0161] (4) Select the next depth W2 and perform the connection operation WidthNodeJoin(Wi,Wj). If the connection is successful and all constraints are satisfied;

[0162] (5) Repeat step 4 until no width that meets the condition can be found, then a packing result PK is generated.

[0163] (6) For PK={W1,…,Wm}, perform a width search on the last layer Wm. Start the search from the next element of Wm in the width sorting results. There is no limit to the depth, but the width is limited to a fixed value of 10. This value is quantitative and can be adjusted.

[0164] (7) The general principle is that if the tree can go down, it will go down; if it cannot go down, it will go right; if it cannot go right, it will go up. At this time, the last element Wm of the result PK will go right. If it can be found, it will go down; otherwise, it will go up.

[0165] (8) This will generate a search tree, and the path from the root node to each leaf node is a boxed result PK; the set of all paths from the root node to the leaf node is PACKS;

[0166] 3.4) High-performance parallel computing programming techniques are employed to select the overall optimal container loading scheme from feasible width combinations. By searching only feasible width combinations, the computational load is reduced exponentially.

[0167] 4) The specific process of the multi-cabinet algorithm is as follows:

[0168] 4.1) Match the heights of the pallets to determine if the heights are compatible;

[0169] The pallets are matched by height using a combination algorithm. If a pallet is stacked in the Y direction and its height is less than 80% of the container height, then it is considered difficult to match. Assuming the operation is GetPalletYMatch(P), it returns 1 for difficult-to-match pallets and 0 otherwise.

[0170] 4.2) Match the width of the pallet to determine if the width is easy to match;

[0171] Width Matching: If the pallet is self-matched in the X direction, it can be rotated. If the sum of the widths is less than 94% of the container width, then the width is difficult to match; otherwise, it is easy to match. Assuming the operation is GetPalletXMatch(P), it returns 1 for difficult matching and 0 otherwise. GetPalletXMatchGap(P) represents the remaining gap after the pallet width is self-matched.

[0172] 4.3) Based on steps 4.1) and 4.2), calculate the matching difficulty value and sort all pallets by difficulty.

[0173] The formula for calculating pallet priority is:

[0174] Priority(P)=10000*GetPalletYMatch(P)+1000*GetPalletXMatch(P)+GetPalletXMatchGap(P) / 10

[0175] 4.4) Select the optimal width combination for each pallet in sequence and connect them, and record the result of the maximum net volume loading MaxNetVol(PACKS): Get the net volume for each PK in the set PACKS, and traverse the set to return the maximum net volume.

[0176] The search termination conditions include: each tray search lasts a maximum of 2 minutes, reaches the preset utilization rate, and is fully loaded;

[0177] Repeat step 4.4 until all pallets are loaded.

[0178] 5) The specific process of the delivery time algorithm is as follows:

[0179] 5.1) Determine the required pallet quantity; the quantity of orders with the current delivery date is the required quantity.

[0180] 5.2) Load all pallets with a quantity greater than 0 first;

[0181] 5.3) If the number of pallets within the current delivery period is insufficient to fill a container, an order for the quantity outside the current delivery period can be placed.

[0182] It should be noted that there are two parallel computing techniques for implementing these algorithms:

[0183] First, OpenGL is used on the CPU for multi-CPU core parallel computing to verify the algorithm and logic. From a computing power perspective, C language under Linux is used for algorithm development because Linux is more efficient than Windows, and C language is one of the most efficient programming languages.

[0184] Second, it is ported to the GPU via CUDA C, taking advantage of the GPU's multi-core parallel computing capabilities and leveraging the fact that the GPU has far more cores than the CPU to improve computing power.

[0185] For those skilled in the art, various corresponding changes and modifications can be made based on the above technical solutions and concepts, and all such changes and modifications should be included within the protection scope of the claims of this invention.

Claims

1. A container loading system for logistics transportation based on algorithms and information technology, characterized in that, This includes the front-end web business system and the back-end algorithm system; The front-end web business system includes an order recording module, an order filtering module, a communication module, and a 3D graphics display module; Order Record Module: Used to record order information placed by customers; the order information includes the shipping destination, order delivery time, and delivery status; Order filtering module: This module allows packing and shipping planners to filter all pending orders destined for the same destination by the shipping destination and select the container type, boundary parameters, and safety parameters. Based on this, the order filtering module generates XML messages in the order of the filtered pending orders. Communication module: Used to send the XML messages generated by the order filtering module to the backend algorithm system through a secure communication mechanism, and to receive the container loading suggestions calculated by the backend algorithm system; 3D Graphics Display Module: Used to dynamically display the container loading suggestions obtained by the backend algorithm system in a 3D graphic format; The backend algorithm system is used to calculate a container loading suggestion scheme that meets the container utilization requirements based on the XML message sent by the frontend Web business system. The container loading suggestion scheme includes the stacking method and stacking order of each commodity pallet, which can be represented in a three-dimensional graphical manner. The algorithms run by the background algorithm system include quicksort, combination, width, multi-cabinet, and delivery time algorithms. 1) Quicksort algorithm: Use a list to store the block elements, and id_list to store the corresponding indices of the sorted blocks in the list. Initialize the id_list of indices corresponding to the data to be sorted in the list according to indices 0 to n. Select the first element in id_list, move all data with indices greater than or equal to the first element to the left, and move all data with indices less than the first element to the right. After the first split operation, two subsequences are formed with the current position of the first element as the dividing line. Repeat the same split operation on the two subsequences until all the split sequences contain only one element. 2) Combinatorial Algorithm: The combinatorial algorithm addresses the heterogeneous bin packing problem. Based on block loading, it generates placement schemes according to a specified loading sequence, incorporating directional and stability constraints. A composite block contains one or more bins with different or the same orientation, and is allowed to contain a small number of gaps that do not affect loading. The specific process is as follows: The list of bins calculated by the quicksort algorithm is placed into `jc_list`. In the first iteration, the first element is combined with each element and concatenated. If successful, the newly generated element is appended to `jc_list`. In the second iteration, the next newly generated element is combined with each element in `jc_list` and concatenated. If successful, the newly generated element is appended to `jc_list`. This second iteration is repeated until no new elements are added or the number of elements reaches the maximum capacity of `jc_list`. 3) The specific process of the width algorithm is as follows: 3.1) Solve for width combinations for all pallets: Assume the available width of the container is CT_WIDTH, and the pallet set is P = {P1,…Pn}, which is a set of pallet types. Each pallet has 4 attributes: length, width, quantity, and rotation. Get the width GetPalletWidth(p); Get the number of pallets using GetPalletQty(p); A width combination is W={P1,…,Pm}, where any two pallets in the width combination are the same type of pallets or different types of pallets, and the same type of pallets may have the same or different orientations. Perform width combination operation: Get the number of times a specific tray has been used: GetWidthComPalletQty(W, Pi) WidthSelfJoin(W) Therefore, the constraint formula is: m<=n, GetPalletWidth(P1)+…+ GetPalletWidth(Pm)<=CT_WIDTH, GetWidthComPalletQty(W,Pi) <=GetPalletQty(Pi),i>=1,i<=m 3.2) Sort the result set of width combinations in reverse order of width value; 3.3) Calculate the optimal net volume packing result by performing different permutations and combinations from the width value sorting results: Assume the set of all width combinations is WP={W1,…,Wn}, a packing result is a permutation of several widths W, and the packing result is described as PK = {W1,…,Wm}; the set of all packing results is described as PACKS = {PK1,…,PKn}, and the width, height and length of the container are CT_XLEN, CT_YLEN, and CT_ZLEN respectively. 3.3.1) Perform the comparison operation as follows: 3.3.1.1) Get the list of pallets with coordinates for the packing results item_list = GetPkPalletItemList(PK), which is used for the subsequent acquisition of sub-compound blocks. It needs to be sorted by height to meet the safety requirement of front high and back low; 3.3.1.2) Compare net volumes using GetPkNetVol(PK), which obtains the net volume of each packing result for subsequent calculations and comparisons, and records the result with the largest net volume; 3.3.1.3) Compare the maximum width using GetPkMaxXLength(item_list), which retrieves the maximum width for comparison. The maximum width cannot exceed the container width. 3.3.1.4) Compare the maximum height using GetPkMaxYLength(item_list), which retrieves the maximum height and is used to ensure that the maximum height does not exceed the container height; 3.3.1.5) Compare the maximum length GetPkMaxZLength(item_list), which is used to obtain the maximum length and is used to compare the length of the container. 3.3.1.6) Compare the number of pallets using GetPkPalletQty(item_list,Pi), which retrieves the number of pallets and ends the calculation when all pallets have been loaded. The constraints for comparison operations are: 1) Any Wi belongs to WP; 2) GetPkMaxXLength(item_list)<= CT_XLEN; 3) GetPkMaxYLength(item_list)<= CT_YLEN; 4) GetPkMaxZLength(item_list)<= CT_ZLEN; 5) GetPkPalletQty(item_list,Pi) <= GetPalletQty(Pi) 6) No two trays can intersect; 3.3.2) Execute the connection operation WidthNodeJoin(Wi,Wj); 3.3.3) The formula for calculating the net volume of the packing is as follows: MaxPkNetVol = PKx, where PKx belongs to the set PACKS and PKx has the largest net volume; 3.3.4) The following calculations are performed based on the breadth-first PK tree search algorithm: (1) Select the pallet Pi to be loaded; (2) Select the width combination that contains the Pi tray from the set WP, and the width with the largest width; (3) Perform a self-connection operation on the width with the largest width mentioned above. (4) Select the next width and perform the connection operation WidthNodeJoin(Wi,Wj). If the connection is successful and all constraints are satisfied; (5) Repeat step (4) until no width that meets the condition can be found, then a packing result PK is generated; (6) For PK = {W1,…,Wm}, perform a width search on the last Wm. Start the search from the next element of Wm in the width sorting results. There is no limit to the depth, but the width is limited to a fixed value of 10. This value is fixed and can be adjusted. (7) The general principle is that if the tree can go down, it will go down; if it cannot go down, it will go right; if it cannot go right, it will go up. At this time, the last element Wm of the result PK will go right. If it can be found, it will go down; otherwise, it will go up. (8) This will generate a search tree, and the path from the root node to each leaf node is a boxed result PK; the set of all paths from the root node to the leaf node is PACKS; 3.4) Parallel computing programming techniques are used to select the overall optimal container loading scheme from feasible width combinations; by searching only feasible width combinations, the amount of computation is reduced exponentially. 4) The specific process of the multi-cabinet algorithm is as follows: 4.1) Match the heights of the pallets to determine if the heights are compatible; The pallets are matched by height using a combination algorithm. If the pallets are stacked in the Y direction and the height is less than 80% of the container height, then the height is difficult to match; otherwise, it is easy to match. Assuming the operation is GetPalletYMatch(P), it returns 1 for difficult matching and 0 otherwise. 4.2) Match the width of the pallet to determine if the width is easy to match; Width Matching: If the pallet can be rotated and self-matched in the X direction, if the sum of the widths is less than 94% of the container width, then the width is difficult to match; otherwise, it is easy to match. Assuming the operation is GetPalletXMatch(P), it returns 1 for difficult matching and 0 otherwise. GetPalletXMatchGap(P) represents the remaining gap after the pallet width is self-matched. 4.3) Based on steps 4.1) and 4.2), calculate the matching difficulty value and sort all pallets by difficulty. The formula for calculating pallet priority is: Priority(P) = 10000*GetPalletYMatch(P) + 1000 * GetPalletXMatch(P) +GetPalletXMatchGap (P) / 10; 4.4) Select the optimal width combination for each pallet in sequence and connect them, and record the result of the maximum net volume loading MaxNetVol(PACKS): Obtain the net volume for each PK in the set PACKS, traverse the set and return the maximum net volume; The search termination conditions include: each tray search lasts a maximum of 2 minutes, reaches the preset utilization rate, and is fully loaded; Repeat step 4.4 until all pallets are loaded; 5) The specific process of the delivery date algorithm is as follows: 5.1) Determine the required pallet quantity; the quantity of orders with the current delivery date is the required quantity. 5.2) Load all pallets with a quantity greater than 0 first; 5.3) If the number of pallets within the current delivery period is insufficient to fill a container, place an order for the quantity of goods outside the current delivery period.

2. The system according to claim 1, characterized in that, It also includes a data interface system; the data interface system is used to connect to a unified ERP business system, and the front-end web business system can interact with the ERP business system through the data interface system.

3. The system according to claim 1, characterized in that, It also includes a manual adjustment system, which is used by container loading planners to manually adjust the container loading suggestions when they find that the suggestions need to be adjusted during the 3D graphic display of the front-end web business system.

Images