1. Introduction
In the 1970s, the aviation industry introduced simulators for crew training to reduce accidents caused by human error, significantly improving the skill level and decision-making ability of crew members [1]. The success of aviation simulators attracted the attention and emulation of other transportation fields. Since the 1990s, simulators have been widely applied in the maritime industry for training purposes [2].
Among these, the importance of marine engine simulators is particularly prominent [3]. These simulators can vividly reproduce the operation of ship engines and related equipment, providing trainees with a safe and controlled environment where they can practice under various simulated scenarios, experiencing the real feel of a ship [4], including mimicking the engine room and audiovisual effects [5,6]. This not only allows trainees to master complex engine system operations but also enhances their ability to respond to emergencies. Additionally, marine engine simulators can simulate various potential malfunctions and abnormal situations, enabling trainees to remain calm when facing real failures, thereby effectively reducing mechanical failures and losses due to operational errors [7].
Through marine engine simulator training, trainees can fully understand the operating principles and processes of engine systems without boarding a real ship [8]. This training method not only saves time and costs but also avoids potential dangers during actual operations. Furthermore, marine engine simulators allow for repeated training, enabling trainees to accumulate experience quickly and improve their skills in a short time [9].
An essential component of the marine engine simulator is the ship’s piping system. The piping system serves as the “nervous system” connecting various critical components of the ship, including the fuel pipelines, cooling water pipelines, and compressed air pipelines [10]. Their reliable operation is fundamental to ensuring the normal navigation and mission execution of the ship [11,12]. For pipelines, especially flexible ones, connections are often the weakest link. Therefore, advanced software is used to model the hydrodynamic phenomena associated with high-pressure fluid flow in the pipelines. Numerical methods are effective for pipeline design, taking into account hydrodynamic phenomena and potential pipeline failures [13]. The simulator realistically reproduces the design and operational conditions of these piping systems, enabling trainees to fully master their operational techniques and thereby reduce human error. It should be noted that modeling the flow inside the pipeline is crucial even at the design stage, as it helps predict the maximum load on the pipeline and design its length, wall thickness, and the number and position of supports. When the working fluid is flowing, especially in long pipelines, the water hammer effect can cause damage or even rupture the pipeline. Therefore, using advanced software to model the hydrodynamic phenomena associated with high-pressure flow is essential. The simulator’s realistic reproduction of the design and operation of these systems enables trainees to master operational techniques fully, reducing human errors [14]. However, programming the ship’s piping system is highly complex and typically requires programmers to handle large amounts of data, which is inefficient.
As a result, there has been growing interest in visual modeling methods for ship piping systems within marine engine simulators, with a focus on dynamic modeling, neural networks, modular modeling, and real-time simulation capabilities. These studies highlight the importance of accurate mathematical models and visual simulation in improving training and operational efficiency in the maritime industry. In response, this paper proposes a visual modeling method for the ship’s piping system. Through this method, the complex programming of the engine piping system becomes more intuitive and efficient, greatly enhancing data processing efficiency. This visual modeling method not only simplifies the work for programmers but also provides more convenient solutions for the management and maintenance of the ship’s piping system, further ensuring the safety and efficient operation of the ship.
To improve the programming efficiency of ship piping systems, significant efforts have been made by programmers. In 2005, Shi et al. used a radial basis function (RBF) neural network to model the marine diesel generator system. The RBF neural network has strong nonlinear approximation capabilities, making it ideal for handling complex multi-input, multi-output (MIMO) systems. In their study, they modeled the generator system by inputting physical quantities such as the diesel engine’s torque, excitation current, and voltage and outputting the generator’s voltage, current, and frequency. The system was thoroughly analyzed. During model training, the authors used supervised learning, training the RBF neural network with extensive experimental data. The results showed that the model accurately predicted the generator’s dynamic response, demonstrating high precision and reliability. The study highlighted the advantages of neural network models in handling nonlinear, complex systems, especially their robustness and adaptability during transient conditions such as sudden load changes. The innovation of this research lies in combining neural networks with traditional diesel generator modeling methods, solving the challenges traditional models face in accurately addressing complex conditions. By using the RBF neural network, the model trained quickly and could be used for real-time simulation of ship power systems. This research offers a new approach to marine diesel generator modeling and lays the foundation for further optimization and expansion [15].
In 2010, Kim I et al. explored how to achieve neutral model visualization of ship piping systems using X3D technology, particularly how to utilize 3D technology to more intuitively display complex piping systems. The researchers built a lightweight 3D visualization framework using X3D, an XML-based 3D graphics standard, to show the layout and connections of ship pipelines. This visualization model could run in a browser, achieving cross-platform display and significantly facilitating the system’s application and dissemination. The paper provided a detailed discussion of the visualization process, including geometric modeling of the pipeline system, texture mapping, and dynamic display of pipeline connections. The research also noted that 3D visualization technology could enhance fault detection, pipeline maintenance, and pipeline improvement design. This provides ship engineers with a crucial tool to help them understand complex piping network systems. Furthermore, the study highlighted the system’s strong scalability, supporting future integration of additional functions, such as fluid dynamics simulation. The innovation of this work lies in utilizing open-source X3D technology to achieve a 3D display of ship piping systems, reducing system complexity and providing a highly operable solution for practical applications [16].
In 2015, Zou et al. summarized the modeling and simulation of ship fuel supply systems, proposing a new sparse-matrix-solving algorithm capable of efficiently handling the flow and pressure distribution in large-scale fuel supply piping systems. The paper discussed in detail the mathematical models of various fuel system components, such as fuel pumps, pipelines, and valves and, based on this, established a dynamic simulation model of the entire supply system. The model is characterized by its ability to handle the system’s dynamic response under different fuel conditions, particularly with adaptive adjustment to fuel viscosity changes as temperature varies. The authors verified the model’s accuracy and real-time performance by integrating the simulation system with an actual ship fuel supply system. The paper mentioned that the system adopted object-oriented programming principles and supported distributed deployment, enabling the simulator to handle larger and more complex ship fuel supply systems. In terms of application, the paper demonstrated the successful application of the simulation system in large ships, including dynamic adjustments during operation and system performance optimization. This model achieved a balance between accuracy and real-time performance and possesses strong scalability, making it adaptable to future demands for more complex fuel supply systems [17].
YOLOv5 plays a significant role in detection and classification. To address the need for posture recognition during fruit commercialization, Wang et al. proposed a real-time apple stem and calyx detection algorithm based on YOLOv5. The study first determined the hyperparameters of the recognition targets and used transfer learning to train the model, improving detection performance. A comparison of YOLOv5 network backbones with different widths and depths showed that YOLOv5s had advantages in detection performance, model weight, and detection speed under the same settings. By optimizing the number of detection heads, feature map size, layers, and channel pruning of YOLOv5s, the algorithm’s complexity was reduced, model parameters and weights decreased by 71%, while mAP and F1 scores only slightly dropped by 1.57% and 2.52%, respectively. After optimization, the algorithm achieved real-time detection at 25.51 FPS on a CPU, with a detection accuracy of 93.89%. This method strikes an optimal balance between detection performance and speed, with low hardware requirements and high practicality. The results are also applicable to other tasks requiring specific fruit postures, providing technical support for improving fruit automation processes [18].
2. General Program Design
2.1. Overall Design of Ship Piping Network Program
As the complexity of ship systems continues to increase, using traditional simulation programming methods to build system simulation models requires significant time. Programmers often need to process a large amount of data to deal with complex parameters and models [19]. This presents a major challenge for those who are not proficient in programming or lack professional programming experience. Traditionally, addressing these challenges relies on advanced programming languages and environments like Matlab and Visual C++. Although these tools are powerful, their complexity demands considerable time for nonprogramming users to learn and adapt.
To address the difficulty of traditional piping program development, this study developed a visual piping model. Designers can first create a piping diagram and generate the corresponding SVG file. This SVG file is then imported into WPF, where pumps, valves, and other equipment are added, along with labels to display flow and pressure. Designers can also set parameters to design the ship piping network. The designed SVG image and the position map of WPF controls are then converted into a PNG format, allowing YOLOv5 object detection technology to recognize them. Through the YOLOv5 recognition simulator, designers can detect the piping diagram created in SVG format and the position map of controls designed in WPF. After integration and processing with Python, the data are saved as a CSV file and then calculated and output through C#.
2.2. Main Functions of the Ship Piping Network Program
The ship piping program developed in this study provides a complete solution for piping system design, analysis, and optimization by integrating SVG graphical interface design, YOLOv5 object recognition, Python data processing, and C# computational output.
2.2.1. Visual Piping Network Design
For graphical interface design, we first use professional drawing tools to create a complete piping diagram based on the provided engineering drawings. The entire pipeline connection layout is displayed clearly and intuitively in graphical form. Once completed, the graphic is saved in SVG format, which has the advantage of maintaining clarity and accuracy at different display sizes and resolutions [20]. Pipes are represented by simple lines in the graphic, while specific symbols are used to mark connection points to ensure structural accuracy and readability.
Next, we will import the SVG files into the WPF system, allowing users to interact with the interface intuitively through WPF’s interactive GUI. WPF’s user interface design capabilities are particularly suited for applications requiring highly customized UIs [21]. On this interface, users can freely drag and position various equipment such as pumps and valves and configure the equipment based on actual requirements. Users can set the maximum allowable flow through the valves and assign each valve a flow label code to display the current flow status. Similarly, users can configure the pump’s starting flow rate and pressure and set tags to display the pump’s pressure and flow rate.
WPF is developed on the .NET framework and is highly integrated with the C# language, enabling developers to fully utilize C#’s powerful features, such as type safety and high execution efficiency. Additionally, when the program starts, the interface will display the current pressure of the pumps and the flow through them, corresponding to the respective label codes for flow and pressure. With this visual operation, users can easily monitor and manage the operation of the entire pipeline system, adjusting equipment parameters in a timely manner to ensure efficient operation and safety of the system.
2.2.2. Object Recognition
The program utilizes YOLOv5 object detection technology to recognize the designed SVG diagrams and the position maps of WPF controls. YOLOv5, through convolutional neural networks (CNN), extracts features from the input images and performs object localization, enabling fast and accurate recognition of various devices and connection points [22]. These parameters, including the location, shape, and size of the devices, are then stored in a database. Its efficient recognition capabilities ensure comprehensive detection and analysis of the pipeline system [23]. Additionally, YOLOv5 excels in detecting small objects and in complex backgrounds, especially when handling diverse pipeline devices and connection points. It can optimize the balance between speed and accuracy by adjusting model size, layers, and other parameters.
During the object recognition process, YOLOv5 not only processes large-scale graphical data quickly but also ensures precise localization of various devices and connection points in complex scenes. These detected parameters are systematically recorded for further analysis and optimization. YOLOv5’s outstanding detection performance enables the system to fully cover all aspects of the pipeline network, ensuring the completeness and accuracy of the detection results. Furthermore, the automated data storage and management functions greatly simplify subsequent maintenance tasks, reduce the need for manual intervention, and enhance the overall efficiency of the system.
2.2.3. Data Conversion and Processing
The recognized data are processed and filtered through Python to ensure accuracy and completeness. This step includes eliminating duplicate and unexpected data to improve the quality of the information, making it suitable for subsequent analysis and processing. The final output is a CSV file that provides a reliable data foundation for further calculations and optimization.
In terms of data conversion, since the data recognized by YOLOv5 may contain duplicates and may not fully meet expectations, Python is used to filter and clean the data. This ensures that only the most relevant and accurate data are retained for future use.
2.2.4. Data Calculation and Display
The program utilizes C# to perform real-time calculations on the input CSV files. The type safety and high execution speed of C# ensure the stability and efficiency of the program [24]. Users simply need to place the CSV file in the specified folder and the program will automatically calculate important parameters such as flow and pressure in the pipeline. The calculation results are displayed in real time on the interface, allowing users to quickly receive feedback and become familiar with the operational steps of the ship’s pipeline network.
3. Program Development and Implementation
To achieve the aforementioned functionality, the program’s development and implementation involve the following specific operations:
3.1. Visualization of the Piping Network
In the initial stage of pipeline network modeling, we used advanced drawing software to create a schematic diagram of the pipeline, as shown in Figure 1. In the diagram, larger rectangles represent storage tanks, thin lines represent pipelines, and the dots where thin lines intersect represent nodes, indicating that multiple pipeline segments are connected at that point. Arrows are used to indicate the direction of fluid flow (for target recognition, all pipelines with a fixed flow direction must be marked with arrows, while pipes without arrows indicate that the liquid can flow in both directions). Different colors are used to distinguish the functions of the pipes and the contents of the storage tanks. In this diagram, the example of a sewage system is used, with brown pipes and storage tanks. Users can also customize the colors, such as red for fire water or black for heavy oil.
After completing the drawing, we saved the pipeline diagram in SVG format and imported it into the WPF environment as the base layer for the design. Subsequently, relevant control parameters, such as the valve’s position, the pump’s position, and the maximum allowable flow, can be set in WPF. This method not only allows for personalized visualization of the pipeline layout but also makes it easier for developers to adjust and optimize the diagram, ensuring it meets the design requirements of complex systems.
In the design of the pipeline system, special attention is given to the visual representation of key components. For example, the pump and valve are shown in gray before they are activated and, when the user clicks on them with the mouse, they change to the color of the pipeline to indicate activation. Monitoring the status of flow and pressure in the pump and valve is particularly important, so we developed monitoring labels (including water level, pressure, and flow). As shown in Figure 2, we developed a set of control styles in WPF and stored them in a reusable resource library. In this example, flow and pressure are labeled with “G” and “P”, respectively. Considering that flow is relatively larger, while pressure is smaller, the flow value retains one decimal place and the pressure value retains two decimal places for accurate representation.
In the pipeline diagram, valves are represented by two opposing triangles. One-way valves are shown as one gray and one white triangle, with the gray part indicating the direction of fluid flow. When the one-way valve opens, the gray part changes to the color of the pipeline, intuitively displaying the flow direction. If both triangles are white, it means the valve is a stop valve, which indicates that flow is blocked. When the stop valve is opened, the triangles change to the color of the pipeline. Different valve types are represented by different shapes, as shown in Figure 3. A triangle embedded in a circle represents a pump, and the direction of the triangle indicates the outlet direction of the pump. When the pump is not activated, it is displayed in gray–black and, when activated, it changes to the color of the pipeline.
In real ships, pumps are usually designed with safety valves to prevent damage to the pump or pipeline due to excessive pressure when the discharge pipe is blocked. By default, pumps in this system are equipped with safety valves but, if the user opens only the pump and the valve at the inlet, the pump pressure will rise quickly until the safety valve opens. If the valve at the outlet is opened, the pump resumes normal operation. The rectangle inside the storage tank represents the water level label, providing a visual indication of the liquid level. In the design, the maximum water level in the tank is 100, with an initial water level of 70%. The water level label shows changes based on user operations. When the maximum water level is reached, water supply cannot continue and will be diverted to other branches. When the minimum water level is reached, water cannot be drawn, causing the pump to idle, and both pressure and flow will drop to zero.
Some storage tanks operate by gravity (without pumps). To ensure accuracy in such cases, it is necessary to set the maximum flow limit for the outlet pipe section. To limit the maximum flow of a pipe section, it is only required to appropriately limit the maximum allowable flow of the valve on that section. This detailed graphical design ensures that operators can clearly identify and interpret various status information within the pipeline network.
When designers need to limit the maximum allowable flow of an outlet pipe section, they only need to set the maximum allowable flow for the pump. Notably, if there are multiple valves on the same pipe section, the maximum allowable flow for that section will take the smallest value of the maximum allowable flow across those valves. This approach allows parameters that cannot be set directly for the pipe section in WPF to be set indirectly through the pump.
3.2. Implementation of Object Recognition
Object recognition is a key aspect of this program, which utilizes YOLOv5 for object detection. YOLOv5 is widely adopted for object recognition tasks due to its high efficiency in real-time detection and high accuracy.
Given the absence of a specialized dataset for marine engine simulators, this paper develops a dataset specifically for the simulator’s pipeline system. First, SVG images were converted into PNG format (as shown in Figure 1) and elements such as Up Arrow, Left Arrow, Down Arrow, Right Arrow, Node, Pipe, and Tank were annotated. Additionally, WPF control diagrams were hidden in the background and saved as PNG files (as shown in Figure 4) and elements like Valve, Up Pump, Down Pump, Left Pump, and Right Pump were annotated. These elements were randomly combined during annotation, using Labelme (5.3.1) for labeling.
Labelme, similar to LabelImg, provides a graphical user interface for annotation but offers more functionality, supporting various annotation shapes such as polygons, rectangles, circles, and polylines, making it ideal for tasks like semantic segmentation [25]. After normalizing the annotated JSON files and converting them to TXT format, the elements were trained using the YOLOv5X-Seg model. This model deepens and widens the network compared to others, enhancing AP accuracy and enabling the training of nonrectangular objects. The parameter settings used are shown in Figure 5.
Upon completing the training, the confidence–accuracy curve is shown in Figure 6. The pipeline recognition reached an accuracy of 0.964, while the control recognition achieved 0.93, indicating the program’s ability to efficiently recognize and locate components within the marine pipeline system.
For the converted SVG images, the positions of components such as Up Arrow, Left Arrow, Down Arrow, Right Arrow, Node, Pipe, and Tank were recognized, including co-ordinates for the top-left, bottom-left, top-right, bottom-right, and center points, which were saved to a specified CSV file. Similarly, for WPF control diagrams, the positions of components like Valve, Up Pump, Down Pump, Left Pump, and Right Pump were recognized with the same co-ordinates and automatically saved to a CSV file.
These steps ensure the efficient recognition and localization of all components in the marine pipeline system, providing accurate and complete data for further processing and analysis. This approach facilitates complex pipeline design and lays a strong foundation for optimizing data processing workflows and enhancing system efficiency.
3.3. Data Integration and Conversion
After filtering the data, we obtained two CSV files containing information about the positions of pipeline network elements and controls. We then performed the following conversion steps on these two files.
First, the labels obtained from object detection were not numbered, so we needed to number the targets. The numbering method was as follows: based on the co-ordinates of the center points, we numbered them first by the X-axis co-ordinates in ascending order. If the X-axis co-ordinates were the same, they were numbered by the Y-axis co-ordinates in ascending order. For the WPF control components, only the center point co-ordinates were retained, and other unnecessary co-ordinates were removed.
For the pipeline segments, in order to combine them into a complete pipeline network, we not only needed the co-ordinates for the top-left, top-right, bottom-left, bottom-right, and center points but also calculated and added the midpoints of the two shortest edges. These co-ordinates were saved in the last two columns of the file, named “nearest_midpoint” and “second_nearest_midpoint”, respectively. The “nearest_midpoint” column holds the point with the smaller X-axis value and, if the X-axis values were the same, the smaller Y-axis point was used.
After calculating the required co-ordinates, we combined all the recognized elements into a ship’s pipeline network and imported them into a C# program for computation. The first column of the network file is named “PipeID”, which contains the names of the pipeline segments, and only the segment numbers recognized from the SVG file need to be extracted, as the pipeline segments are the most important part of the network.
The second column of the network file is named “Name”, which contains the names of the control elements on the pipeline segments. When the program determines that a pipeline segment overlaps with a WPF control (by calculating the distance between the centerline formed by the midpoints of the two shortest edges of the pipeline segment and the center point of the control and, if it is less than 50, it is considered overlapping), the program fills the corresponding cell with the name of the control.
The third column of the network file is named “PipeDirection”, which contains the flow direction of the pipeline segment. The program determines this based on the type of overlapping arrow. If it is a Right Arrow or Down Arrow, the cell will contain “AB”. If it is a Left Arrow or Up Arrow, the cell will contain “BA”. If there is no arrow, “CC” is entered, indicating that the fluid can flow in both directions.
The fourth and fifth columns of the network file are named “PipeConnecterA” and “PipeConnecterB”, respectively, and they record the co-ordinates that overlap with the “nearest_midpoint” and “second_nearest_midpoint” columns (top-left and bottom-right co-ordinates) from the SVG result file. When the program determines that the “nearest_midpoint” of Pipe1 overlaps with the “second_nearest_midpoint” of Pipe2, it fills “2B” in Pipe1’s “PipeConnecterA” column and “1A” in Pipe2’s “PipeConnecterB” column. If multiple pipelines overlap, they are separated by commas.
The sixth and seventh columns of the network file are named “IsSource” and “IsTerminal”, respectively, and they record whether the pipeline segment is a source segment or a terminal segment. After determining the values in the third, fourth, and fifth columns, if the result in the third column is “AB” and there is no result in the fourth column (i.e., there is no pipeline segment connected in the “PipeConnecterA” column), the corresponding cell in the sixth column is filled with “TURE”, indicating that the segment is a source segment. Similarly, if the result in the third column is “BA” and there is no result in the fourth column (i.e., there is no pipeline segment connected in the “PipeConnecterB” column), the corresponding cell in the sixth column is filled with “TURE”, indicating that the segment is a source segment.
If the result in the third column is “AB” and there is no result in the fifth column (i.e., there is no pipeline segment connected in the “PipeConnecterB” column), the corresponding cell in the seventh column is filled with “TURE”, indicating that the segment is a terminal segment. Similarly, if the result in the third column is “BA” and there is no result in the fourth column (i.e., there is no pipeline segment connected in the “PipeConnecterA” column), the corresponding cell in the seventh column is filled with “TURE”, indicating that the segment is a terminal segment.
Through the above steps, we not only achieved effective data integration and conversion but also ensured the accuracy and completeness of the data, laying a solid foundation for the subsequent analysis and computation of the ship’s pipeline network.
3.4. Real-Time Data Calculation and Display
After data integration and conversion, calculations are performed within the C# program. During the program’s operation, when the user clicks a valve or pump, it changes to the color of the pipeline, indicating that it is open, and the signal is sent to the calculation program. Next, the program analyzes the pipeline network to determine which segments allow fluid flow. Using an iterative method, it reads and evaluates the control states on the segments. When the number of open controls on a segment matches the number of controls shown in the CSV file, the program determines that the segment is in a flow-allowed state. When all the segments from the source to the terminal are in a flow-allowed state, the pipeline containing those segments is considered to allow fluid flow.
Once the pipeline is confirmed to allow flow, the flow calculation and transmission process begins. The flow calculation proceeds as follows: based on the pump’s power and the pipeline flow direction from the CSV, the program requests flow from the source segment to the pump inlet. If the maximum upstream segment flow exceeds the pump’s rated flow, the system requests flow based on the pump’s rated flow. If the upstream segment’s maximum flow is below the pump’s rated flow, the system adjusts the request according to the segment’s flow limit.
The flow is temporarily stored at the upstream node of each pump and continuously requested from upstream nodes until it reaches the source. When multiple branches exist at an upstream node, the system applies an equal flow distribution strategy, requesting flow evenly from each branch. If the maximum flow limit of any branch is lower than the average, the system adjusts the request to that branch’s maximum flow and distributes the remaining flow to the other branches at the same level. When all branches reach their maximum flow limits, the system automatically adjusts the upstream node’s maximum flow setting to the sum of the flow limits of all branches.
Once flow is assigned to the source, it is distributed downstream to each branch node along the pipeline. Pump outlet handling follows a similar process, with the flow stored at the pump node being distributed downstream according to the maximum allowable value of the downstream segment. The flow is adjusted based on the principles of average distribution and maximum flow limits until it reaches the terminal.
This entire process ensures accurate and balanced flow distribution from the source to the terminal segments. Ultimately, all calculated and distributed flow values are displayed in the pipeline node processing flow, ensuring the intuitive and logical clarity of the pipeline network operations. The network processing flow is illustrated in Figure 7.
4. Model Operation Example
This paper takes the sewage system of a certain ship as an example. After the programmer displays the parameters such as pipelines, flow direction, nodes, and tanks from the drawings in an SVG format and positions the controls like the pumps, valves, flow labels “Gpipe”, and pressure labels “Ppipe” in the required places (as shown in Figure 8), the SVG images are then converted into PNG format. The WPF control image is also saved as a PNG after hiding the base map. These two images are then fed into YOLOv5 for recognition. The results are shown in Figure 9 and Figure 10, with the numbers indicating the confidence scores. From the results, it can be seen that most of the confidence scores are above 0.75, indicating that YOLOv5 can accurately recognize various pipeline elements and control components in the sewage system. YOLOv5 also identifies and saves the position parameters of the elements in the images to a designated CSV file, as shown in Table 1. After data integration and conversion, the data are fed into the pipeline network calculation program.
When the user enters the program, the interface is displayed as shown in Figure 7. Taking the “Clean Drain Tank” module as an example, when the user clicks on controls such as pumps and valves, the corresponding controls will change to the color of the pipeline to indicate they are open. Once the three valves and one pump on the left side are all opened, the C# calculation program will determine that the pipe segment is flowing. Since this pipe segment serves as both the source and terminal segment, the program will conclude that the pipeline is open. Then, the pre-entered flow and pressure values will be calculated and displayed on the corresponding labels. On the right side, where no pump is running, when the user opens the corresponding valve, since this pipeline has only one valve, the program will read the data stored in the valve and display it. In cases where there is a branch, the flow will be evenly distributed. Figure 11 shows the program display after the user has completed several steps.
From the figures above, it can be seen that the program can calculate parameters such as flow and pressure when there is no pump in the pipeline, as well as when there is a pump, with the inlet being the outlet of another pump. The results are displayed in specified locations, allowing the user to intuitively observe the real-time impact of operations on the entire pipeline network system.
5. Conclusions
This paper presents an innovative approach to visual modeling for ship piping systems, aimed at addressing the challenges faced by traditional programming methods when handling complex piping networks. The method combines SVG images with WPF controls, utilizes YOLOv5 for object detection, generates corresponding CSV files, and, finally, uses C# for real-time computation and data display. This process significantly enhances programming efficiency and reduces the potential for human error.
Firstly, the system provides an intuitive graphical interface, allowing users to complete complex piping designs through simple drag-and-drop operations, which greatly benefits nonprogrammers. Additionally, by customizing pipe attributes such as maximum flow rate and flow direction, the accuracy of the piping model is further improved. The use of SVG images ensures clarity across different display sizes, while the integration of YOLOv5 simplifies the object detection and data management process, ensuring the correct identification and positioning of each pipeline device.
In terms of data processing, a Python program filters and processes the data recognized by YOLOv5, ensuring data integrity and accuracy, ultimately generating CSV files suitable for real-time computation. This method visualizes the complex piping design process, making data processing more efficient while ensuring the reliability and safety of the design. The C# program processes these CSV files in real time, ensuring real-time display and updates of flow and pressure data within the piping system, providing users with immediate feedback.
In the future, this method is expected to be widely used in ship piping system design and education, playing a larger role in industry practices. It not only improves work efficiency but also enables nontechnical personnel to easily participate in the design and optimization of piping systems, promoting the shipbuilding industry toward greater intelligence and automation. Additionally, similar visual modeling approaches could be applied to the design and simulation of piping networks in aviation fuel, hydraulic, and air conditioning systems to optimize network layout and fluid flow.
Conceptualization, X.W. and Z.H.; methodology, X.W. and Z.H.; software, X.W.; validation, X.W., Z.H., S.L. and Z.Y.; formal analysis, S.L. and Z.Y.; investigation, S.L.; resources, Z.H.; data curation, X.W. and Z.H.; writing—original draft preparation, X.W.; writing—review and editing, X.W.; visualization, X.W.; supervision, X.W.; project administration, X.W.; funding acquisition, Z.H. All authors have read and agreed to the published version of the manuscript.
Not applicable.
Not applicable.
The data presented in this study are available on request from the corresponding author. The data are not publicly available due to privacy.
The authors extend their appreciation to the anonymous reviewers for their valuable feedback.
The authors declare no conflicts of interest.
| SVG | Scalable Vector Graphics |
| WPF | Windows Presentation Foundation |
| YOLOv5 | You Only Look Once version 5 |
| CSV | Comma-Separated Values |
| C# | C Sharp |
| RBF | radial basis function |
| MIMO | multi-input, multi-output |
| CNN | Convolutional Neural Networks |
Footnotes
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.
CSV generated after detection and processing.
| PipeID | Name | PipeDirection | PipeConnecterA | PipeConnecterB | IsSource | IsTerminal |
|---|---|---|---|---|---|---|
| 1 | LineValve7 | BA | 9A | TURE | FALSE | |
| 2 | LineValve1, LineValve2, LineValve3, LinePump1 | BA | TURE | TURE | ||
| 3 | LineValve4 | BA | 8A | TURE | FALSE | |
| 4 | BA | 6A | 5A, 7A | FALSE | FALSE | |
| 5 | LineValve5 | BA | 4B, 7A | TURE | FALSE | |
| 6 | AB | 4A | FALSE | TURE | ||
| 7 | AB | 4B, 5A | FALSE | TURE | ||
| 8 | AB | 3A | FALSE | FALSE | ||
| 9 | LineValve7 | AB | 1A | 15B, 16A | FALSE | FALSE |
| 10 | LineValve6 | BA | 8B, 11A | TURE | FALSE | |
| 11 | AB | 8B, 10A | 16B, 17A | FALSE | TURE | |
| 12 | LineValve8 | BA | 14A, 18A | TURE | FALSE | |
| 13 | LineValve9 | AB | 14B15A | FALSE | FALSE | |
| 14 | LinePump2V | BA | 12B, 18A | 13B, 15A | FALSE | FALSE |
| 15 | BA | 13B, 14B | 9B, 16A | FALSE | FALSE | |
| 16 | LineValve10 | BA | 9B, 15B | 11B, 17A, 19A | FALSE | FALSE |
| 17 | LineValve11 | BA | 11B, 16B, 19A | FALSE | FALSE | |
| 18 | LineValve12 | AB | 12B, 14A | FALSE | TURE | |
| 19 | CC | 11B, 16B, 17A | 22A, 23A | FALSE | FALSE | |
| 20 | LineValve14 | BA | 24A, 28A | FALSE | TURE | |
| 21 | LineValve15 | BA | 24B, 29A | FALSE | TURE | |
| 22 | LineValve13 | BA | 19B, 23A | TURE | FALSE | |
| 23 | CC | 19B, 22A | 27B | FALSE | FALSE | |
| 24 | BA | 20B, 28A | 21B, 25A, 29A | FALSE | FALSE | |
| 25 | BA | 21B, 24B, 29A | 26A, 33A | FALSE | FALSE | |
| 26 | LineValve16, LinePump3 | BA | 25B, 33A | 27A, 30A | FALSE | FALSE |
| 27 | LineValve17 | BA | 26B, 30A | 23B, 31A | FALSE | FALSE |
| 28 | LineValve18 | AB | 24A | FALSE | TURE | |
| 29 | LineValve19 | AB | 21B, 24B, 29A | FALSE | TURE | |
| 30 | LineValve20 | BA | 26B, 27A | TURE | FALSE | |
| 31 | CC | 23B, 27B | 32A, 34A | FALSE | FALSE | |
| 32 | LineValve21 | BA | 31B, 34A | TURE | FALSE | |
| 33 | CC | 25B, 26A | 40B, 41A | FALSE | FALSE | |
| 34 | CC | 31B, 32A | 35A, 36A | FALSE | FALSE | |
| 35 | LineValve22 | BA | 34B, 36A | TURE | FALSE | |
| 36 | CC | 34B, 35A | 42B, 46A | FALSE | FALSE | |
| 37 | LineValve23 | BA | 39A, 43A | FALSE | TURE | |
| 38 | LineValve24 | BA | 39B, 40A, 44A | FALSE | TURE | |
| 39 | BA | 37B, 43A | 38B, 40A, 44A | FALSE | FALSE | |
| 40 | BA | 38B, 39B, 44A | 33B, 41A | FALSE | FALSE | |
| 41 | LineValve25, LinePump4 | BA | 33B, 40B | 42A, 47A | FALSE | FALSE |
| 42 | LineValve26 | BA | 41B, 47A | 36B, 45A | FALSE | FALSE |
| 43 | LineValve27 | AB | 37B, 39A | FALSE | TURE | |
| 44 | LineValve28 | AB | 38B, 39B, 40A | FALSE | TURE | |
| 45 | BA | 36B, 42A | 46A, 48A | |||
| 46 | LineValve30 | BA | 45B, 48A | TURE | FALSE | |
| 47 | LineValve29 | BA | 41B, 42A | FALSE | FALSE | |
| 48 | BA | 45B, 46A | 49B, 50A | FALSE | FALSE | |
| 49 | LineValve31 | AB | 48B, 50A | TURE | FALSE | |
| 50 | LineValve32 | BA | 48B, 49B | TURE | FALSE |
References
1. Sardar, A.; Garaniya, V.; Anantharaman, M.; Abbassi, R.; Khan, F. Comparison between simulation and conventional training: Expanding the concept of social fidelity. Process Saf. Prog.; 2022; 41, pp. S27-S38. [DOI: https://dx.doi.org/10.1002/prs.12361]
2. Chauvin, C. Human Factors and Maritime Safety. J. Navig.; 2011; 64, pp. 625-632. [DOI: https://dx.doi.org/10.1017/S0373463311000142]
3. Ceylan, B.O.; Karatuğ, Ç.; Arslanoğlu, Y. A novel methodology for the use of engine simulators as a tool in academic studies. J. Mar. Sci. Technol.; 2022; 27, pp. 1220-1232. [DOI: https://dx.doi.org/10.1007/s00773-022-00902-9]
4. Hanzu-Pazara, R.; Barsan, E.; Arsenie, P.; Chiotoroiu, L.; Raicu, G. Reducing of maritime accidents caused by human factors using simulators in training process. J. Mar. Res.; 2018; 5, pp. 3-18.
5. Hontvedt, M.; Arnseth, H.C. On the bridge to learn: Analysing the social organization of nautical instruction in a ship simulator. Int. J. Comput.-Support. Collab. Learn.; 2013; 8, pp. 89-112. [DOI: https://dx.doi.org/10.1007/s11412-013-9166-3]
6. Liu, D.; Yu, J.; Macchiarella, N.D.; Vincenzi, D.A. Simulation fidelity. Human Factors in Simulation and Training; CRC Press: Boca Raton, FL, USA, 2008; pp. 91-108.
7. Cwilewicz, R.; Tomczak, L. Improvement of ship operational safety as a result of the application of virtual reality engine room simulators. WIT Trans. Inf. Commun. Technol.; 2008; 39, pp. 535-544.
8. Shen, H.; Zhang, J.; Zeng, H.; Feng, J. Development of a virtual training system for marine engineers. Proceedings of the 2015 4th International Conference on Computer Science and Network Technology (ICCSNT); Harbin, China, 19–20 December 2015; pp. 28-32.
9. Zeng, H.; Zhang, J.D.; Yao, W.L.; Zhang, X.J. CAVE Based Visual System Design and Implementation in Marine Engine Room Simulation. The 19th International Conference on Industrial Engineering and Engineering Management; Qi, E.; Shen, J.; Dou, R. Springer: Berlin/Heidelberg, Germany, 2013.
10. Crawford, J. Marine and Offshore Pumping and Piping Systems; Elsevier: Amsterdam, The Netherlands, 2016.
11. Nikitakos, N.; Sirris, I.; Dalaklis, D.; Papachristos, D.; Tsoukalas, V.D. Game-based learning for maritime education and training: The case of Trader of the World. WMU J. Marit. Aff.; 2017; 16, pp. 265-291. [DOI: https://dx.doi.org/10.1007/s13437-016-0119-3]
12. Hjelmervik, K.; Nazir, S.; Myhrvold, A. Simulator training for maritime complex tasks: An experimental study. WMU J. Marit. Aff.; 2018; 17, pp. 17-30. [DOI: https://dx.doi.org/10.1007/s13437-017-0133-0]
13. Karpenko, M. Landing gear failures connected with high-pressure hoses and analysis of trends in aircraft technical problems. Aviation; 2022; 26, pp. 145-152. [DOI: https://dx.doi.org/10.3846/aviation.2022.17751]
14. Urbanowicz, K.; Bergant, A.; Stosiak, M.; Karpenko, M.; Bogdevičius, M. Developments in analytical wall shear stress modelling for water hammer phenomena. J. Sound Vib.; 2023; 562, 117848.
15. Shi, W.; Yang, J.; Tang, T. RBF NN based marine diesel engine generator modeling. Proceedings of the 2005, American Control Conference; Portland, OR, USA, 8–10 June 2005; Volume 4, pp. 2745-2749.
16. Kim, I.; Cho, G.; Hwang, J.; Li, J.; Han, S. Visualization of neutral model of ship pipe system using X3D. Cooperative Design, Visualization, and Engineering: 7th International Conference, CDVE 2010, Calvia, Mallorca, Spain, 19–22 September 2010. Proceedings; Springer: Berlin/Heidelberg, Germany, 2010; pp. 218-228.
17. Zou, C.; Sun, J. Modeling and Simulation of Ship Fuel Supply Unit. Proceedings of the 2015 7th International Conference on Intelligent Human-Machine Systems and Cybernetics; Hangzhou, China, 26–27 August 2015; Volume 1, pp. 199-202.
18. Wang, Z.; Jin, L.; Wang, S.; Xu, H. Apple stem/calyx real-time recognition using YOLO-v5 algorithm for fruit automatic loading system. Postharvest Biol. Technol.; 2022; 185, 111808. [DOI: https://dx.doi.org/10.1016/j.postharvbio.2021.111808]
19. Schenk, T.; Gilg, A.B.; Mühlbauer, M.; Rosen, R.; Wehrstedt, J.C. Architecture for modeling and simulation of technical systems along their lifecycle. Comput. Visual Sci.; 2015; 17, pp. 167-183. [DOI: https://dx.doi.org/10.1007/s00791-015-0256-9]
20. Goh, D.; Wang, J. Designing a virtual exhibition using Scalable Vector Graphics. Aslib Proc.; 2004; 56, pp. 144-155.
21. Kozminski, A. Windows Presentation Foundation (WPF) technology meets the challenges of operator interface design in automatic test systems. Proceedings of the 2012 IEEE AUTOTESTCON Proceedings; Anaheim, CA, USA, 10–13 September 2012; pp. 80-83.
22. Wang, J.; Chen, Y.; Dong, Z.; Gao, M. Improved YOLOv5 network for real-time multi-scale traffic sign detection. Neural Comput. Appl.; 2023; 35, pp. 7853-7865.
23. Liu, Y.; Lu, B.; Peng, J.; Zhang, Z. Research on the use of YOLOv5 object detection algorithm in mask wearing recognition. World Sci. Res. J.; 2020; 6, pp. 276-284.
24. Shakhov, A.; Kupraty, O. Basic project of autonomous main engine control and it implementation in C# (C sharp) environment. Proceedings of the 2021 IEEE 16th International Conference on Computer Sciences and Information Technologies (CSIT); Lviv, Ukraine, 22–25 September 2021; pp. 319-322.
25. Torralba, A.; Russell, B.C.; Yuen, J. Labelme: Online image annotation and applications. Proc. IEEE; 2010; 98, pp. 1467-1484. [DOI: https://dx.doi.org/10.1109/JPROC.2010.2050290]
© 2024 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https://creativecommons.org/licenses/by/4.0/). Notwithstanding the ProQuest Terms and Conditions, you may use this content in accordance with the terms of the License.
Details
; He, Zhibin 1 ; Liu, Shufeng 2 ; Yu, Zhongkai 2 1 College of Marine Engineering, Dalian Maritime University, Dalian 116206, China;
2 Department of Navigation, Shandong Transport Vocational College, Weifang 261206, China;