Naked-eye 3D high-definition image transmission and display method in giant spherical building

Abstract

The invention discloses a naked-eye 3D high-definition image transmission and display method in a giant spherical building, and relates to the technical field of image transmission, a storage process is monitored in real time, the work progress of each storage thread is calculated, a storage result is compared with an image transmission request at the front end, a corresponding storage strategy is generated based on the comparison result, and the storage strategy is stored in the giant spherical building. The method comprises the following steps: after all image segmented files are stored, receiving an image merging request sent by a front end, starting image merging processing, merging a plurality of segmented files by a server, generating an image file, and after image merging is completed, automatically optimizing parameters of the merged image according to real-time feedback and display requirements, and the image display effect is adjusted in real time according to the display system configuration and the audience position. According to the display system, the storage strategy is dynamically adjusted according to different storage deployment types, stable image transmission is ensured, image parameters are automatically optimized to adapt to a new environment, and the display quality and audience experience are improved.

Description

Technical Field

[0001] The present invention relates to the field of image transmission technology, and in particular to a method for transmitting and displaying naked-eye 3D high-definition images in a giant spherical building. Background Art

[0002] With the continuous advancement of science and technology and the continuous innovation of visual technology, naked-eye 3D technology has been applied in many fields such as entertainment, advertising, exhibitions and theme parks. This technology can provide audiences with a stereoscopic visual experience directly through the parallax effect without relying on traditional 3D glasses. Naked-eye 3D technology uses the differences in perspectives, image layering and optical principles to present an immersive three-dimensional effect to the audience, and is deeply loved by consumers and the industry.

[0003] The existing technology has the following defects: 1. The traditional image storage and transmission process lacks an effective monitoring and feedback mechanism. This results in an inability to adjust or optimize the image storage process and display effects in a timely manner when transmission or storage anomalies occur. Existing technologies are also unable to automatically adjust the display effects when environmental conditions (such as lighting and viewer position) change, leading to unstable display quality. 2. The image storage method is usually fixed and lacks flexibility. For example, when the server and the storage system are physically far apart, or the network bandwidth is limited, the system cannot dynamically adjust the storage and transmission methods according to the real-time situation, resulting in limited image display quality. Especially when the network bandwidth is low or multiple devices share the bandwidth, there is a risk of image quality degradation or data loss.

[0004] Based on this, the present invention proposes a method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building. According to different storage deployment types, the storage strategy is dynamically adjusted to ensure stable image transmission, and image parameters are automatically optimized to adapt to the new environment, thereby improving display quality and audience experience. Summary of the Invention

[0005] The purpose of the present invention is to provide a method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building, so as to overcome the shortcomings of the background technology.

[0006] To achieve the above-mentioned object, the present invention provides the following technical solution: a method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building, the display method comprising the following steps: The display system receives an asynchronous image transmission request from the front end and starts the transmission process after responding to the request, the request including segmentation information of the image file; Determine whether to perform parallel storage based on the image storage deployment type of the display system. Based on the received asynchronous image transfer request, analyze the image file storage requirements again and start the segmented storage process. Monitor the storage process in real time, calculate the work progress of each storage thread, compare the storage results with the front-end image transmission request, and generate the corresponding storage strategy based on the comparison results; After all the image segment files are stored, the server receives an image merging request from the front end, starts the image merging process, and merges multiple segment files to generate an image file; After the image merging is completed, the parameters of the merged image are automatically optimized according to real-time feedback and display requirements, and the image display effect is adjusted in real time according to the display system configuration and the audience position.

[0007] In a preferred embodiment, after the image merging is completed, the parameters of the merged image are automatically optimized according to the real-time feedback and display requirements, including the following steps: Automatically adjust image brightness, contrast, and color saturation parameters based on real-time feedback and display requirements; Compensate for brightness based on the current ambient light intensity, adjust contrast based on image content and 3D display requirements, and adjust image color saturation based on the color rendering capabilities of the display device and the viewer's position.

[0008] In a preferred embodiment, adjusting the image display effect in real time according to the display system configuration and the viewer position includes the following steps: By monitoring the audience's position and angle in real time, the parallax value is calculated. According to the relative distance between the audience and the display screen, the parallax adjustment value of each image segment is calculated, and the image display effect is dynamically adjusted; Adjust the brightness, contrast, and saturation of the image based on your audience's viewing angle.

[0009] In a preferred embodiment, starting the image merging process, the server merges multiple segmented files to generate an image file, including the following steps: Read each image segment in sequence according to the sorted order and merge them. In the merging process, a step-by-step splicing method is adopted to write the data blocks of each segment file into the target image file in sequence. After all segmented files are successfully merged, the size, format, and other metadata of the merged image file are checked, the merge execution result is generated, and returned to the front end to notify the front end that the image merge is complete.

[0010] In a preferred embodiment, the storage process is monitored in real time, the work progress of each storage thread is calculated, and the storage results are compared with the image transmission request of the front end. Based on the comparison results, a corresponding storage strategy is generated, including the following steps: Track the progress of each storage thread in real time, including the number of bytes stored, completed storage tasks, and estimated completion time; When each thread starts storing data, a unique identifier is assigned to the thread and the start time is recorded. During the storage process, the work progress of each thread is periodically obtained, and the ratio of the number of completed stored bytes to the total number of bytes is calculated. After the storage process is completed, the storage results of each thread are compared with the segment sequence number and size in the front-end transmission request to verify whether each segment is successfully stored; If a storage anomaly occurs, the storage policy will be automatically adjusted, including re-requesting failed segments, adjusting storage thread priorities, restarting storage processes, or reallocating storage tasks based on bandwidth.

[0011] In a preferred embodiment, based on the received asynchronous image transmission request, the storage requirements of the image file are analyzed again and then the segmented storage process is started, which includes the following steps: When the front end sends an asynchronous image transmission request, it extracts information including the image segment address, sequence number, segment size, and total number of segments; Extract each image segment information from the front-end request and determine the storage strategy based on the segment size, including parallel storage and serial storage; If the server and storage service are deployed on the same server and the network bandwidth is not limited, serial storage is used; If the storage service and data processing service are deployed on different servers and there is bandwidth limitation, parallel storage is performed based on the network bandwidth and segment size; After the secondary analysis of storage requirements is completed, the image segmentation storage process is started.

[0012] In a preferred embodiment, the serial storage strategy includes the following steps: Receive and store each image segment in sequence according to the segment sequence number in the front-end request. Each segment will go through an independent storage process until all segments are stored. After each storage task is completed, confirm that the segment is stored successfully and continue to process the next segment; When storing each segment, the storage progress is synchronized to the front end in real time. If a segment storage fails, the retransmission mechanism is triggered and the upload of the segment is re-requested.

[0013] In a preferred embodiment, the parallel storage strategy includes the following steps: Dynamically allocate storage tasks based on network bandwidth and segment size; On each server, multiple threads are started to process the image segment storage task in parallel. Each thread is responsible for storing one or more segments and returns the storage results after the storage is completed. After each segment is stored, the storage status is recorded and the current storage progress is synchronized with the front-end; In parallel storage mode, the priority and resource allocation of storage tasks are dynamically adjusted according to the actual network bandwidth.

[0014] In a preferred embodiment, determining whether to perform parallel storage according to the image storage deployment type of the display system includes the following steps: Image storage deployment types for display systems include single-server storage, multi-server storage, and cloud storage: If the current deployment is determined to be single-server storage, all image segments rely on single-thread storage, and all segments are stored sequentially within one thread; If deployed as multi-server storage, enable parallel storage mode and assign different threads or servers to process different image segment files.

[0015] In a preferred embodiment, an asynchronous image transmission request is received from the front end, and the transmission process is started after responding to the request. The request includes segmentation information of the image file, and the segmentation information includes segment address, segment sequence number, size of each segment and total number of image segments.

[0016] In the above technical solution, the technical effects and advantages provided by the present invention are: The present invention determines whether to perform parallel storage based on the image storage deployment type of the display system. When the deployment type allows, parallel storage is performed according to the size of each segment. Based on the received asynchronous image transmission request, the storage requirements of the image file are secondary analyzed and the segment storage process is started. The storage process is monitored in real time, the work progress of each storage thread is calculated, and the storage result is compared with the image transmission request of the front end. Based on the comparison result, a corresponding storage strategy is generated. After all the image segment files are stored, an image merging request sent by the front end is received, and the image merging process is started. The server merges multiple segment files to generate an image file. After the image merging is completed, the parameters of the merged image are automatically optimized according to real-time feedback and display requirements, and the image display effect is adjusted in real time according to the display system configuration and the viewer's position. The display system dynamically adjusts the storage strategy according to different storage deployment types to ensure stable image transmission, and automatically optimizes image parameters to adapt to the new environment, thereby improving display quality and viewer experience. BRIEF DESCRIPTION OF THE DRAWINGS

[0017] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments. Obviously, the drawings described below are only some embodiments described in the present invention. For ordinary technicians in this field, other drawings can also be obtained based on these drawings.

[0018] Figure 1 Flowchart of the present invention.

[0019] Figure 2 This is a diagram of the architecture of the present invention. DETAILED DESCRIPTION

[0020] To make the objectives, technical solutions, and advantages of the embodiments of the present invention more clear, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the accompanying drawings of the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. All other embodiments obtained by ordinary technicians in this field based on the embodiments of the present invention without making any creative efforts shall fall within the scope of protection of the present invention.

[0021] Example: See Figure 1 As shown, the method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building in this embodiment includes the following steps: First, the system receives an asynchronous image transfer request from the front-end and initiates the transfer process after responding to the request. This request includes information about the image file segments, such as the segment address, segment sequence number, each segment size, and the total number of image segments. Based on this information, the system prepares to process the multiple image segments received.

[0022] The system's image storage deployment type determines whether to enable parallel storage. If the deployment type allows, the system will store each segment in parallel based on its size to improve storage efficiency. The system will process multiple segment files until all segments are stored.

[0023] Based on the asynchronous image transfer request received, the image file's storage requirements are analyzed again, initiating the segmented storage process. If the server and file storage service are deployed on the same server and are not limited by network bandwidth, serial storage is used. If the data processing and storage services are deployed on different servers, parallel storage is performed based on network bandwidth and the preset storage size. This ensures that each image segment is stored without delay and synchronized with the front-end request during the storage process.

[0024] The storage process is monitored in real time, the progress of each storage thread is calculated, and the storage results are compared with the image transfer request from the front-end. When all segmented files are successfully stored, the system generates an image storage execution result and sends it to the front-end. If any anomalies occur during the storage process, the system automatically adjusts the storage strategy accordingly to ensure image data integrity and transfer efficiency.

[0025] After all image segment files are stored, the front-end receives an image merge request. This request is generated based on the storage execution results. The front-end uses this request to notify the server to start merging the stored image segments. After the system confirms the merge request, the image merging process begins.

[0026] Based on the merge request, the server merges multiple segmented files to generate a complete HD image file. During the merging process, the system will ensure that the merged image is seamlessly connected and maintains image integrity and quality based on the order of stored files and image segmentation information.

[0027] After the images are merged, the system further optimizes the merged image based on real-time feedback and display requirements. This includes automatically adjusting image parameters such as brightness, contrast, and color saturation to meet the requirements of the naked-eye 3D display system. The system adjusts the image display based on the display system configuration and viewer position to ensure the best 3D effect.

[0028] After the image transmission and display process is complete, the system performs regular monitoring and optimization to ensure the stability of high-definition image display. Image storage and transmission protocols are regularly updated, and storage devices and network bandwidth are checked to maintain efficient system performance over extended periods of use. Furthermore, the system collects user feedback and optimizes storage and display strategies to ensure even more efficient and accurate transmission and display the next time.

[0029] This application determines whether to perform parallel storage based on the image storage deployment type of the display system. When the deployment type allows, parallel storage is performed based on the size of each segment. Based on the received asynchronous image transmission request, the storage requirements of the image file are analyzed again and the segmented storage process is started. The storage process is monitored in real time, the work progress of each storage thread is calculated, and the storage results are compared with the image transmission request of the front end. Based on the comparison results, a corresponding storage strategy is generated. After all the image segmented files are stored, the image merging request sent by the front end is received, and the image merging process is started. The server merges multiple segmented files to generate an image file. After the image merging is completed, the parameters of the merged image are automatically optimized based on real-time feedback and display requirements, and the image display effect is adjusted in real time based on the display system configuration and the audience position. The display system dynamically adjusts the storage strategy according to different storage deployment types to ensure stable image transmission, and automatically optimizes image parameters to adapt to the new environment, thereby improving display quality and audience experience.

[0030] See also Figure 2 As shown, this embodiment also provides a naked-eye 3D high-definition image transmission and display system in a giant spherical building, including an image receiving module, a storage and analysis module, and an image merging and optimization module; Image receiving module: receives asynchronous image transmission requests from the front end and starts the transmission process after responding to the request. The request includes the segmentation information of the image file, which is sent to the storage analysis module and the image merging and optimization module; Storage analysis module: Determines whether to perform parallel storage based on the image storage deployment type. When the deployment type allows, performs parallel storage based on the size of each segment. Based on the received asynchronous image transfer request, it analyzes the storage requirements of the image file and starts the segment storage process. It monitors the storage process in real time, calculates the work progress of each storage thread, and compares the storage results with the front-end image transfer request. Based on the comparison results, it generates a corresponding storage strategy and sends the storage results to the image merging and optimization module. Image merging and optimization module: After all the image segmentation files are stored, the server receives the image merging request sent by the front end and starts the image merging process. The server merges multiple segmentation files to generate an image file. After the image merging is completed, the parameters of the merged image are automatically optimized according to real-time feedback and display requirements, and the image display effect is adjusted in real time according to the configuration and viewer position.

[0031] First, the system receives an asynchronous image transfer request from the front-end and initiates the transfer process after responding to the request. This request includes information about the image file segments, such as the segment address, segment sequence number, each segment size, and the total number of image segments. Based on this information, the system prepares to process the multiple image segments received.

[0032] In the image transmission system, the system first receives an asynchronous image transmission request from the front end. The system responds to the request and initiates the subsequent image transmission process. The asynchronous image transmission request contains important information about the image file segmentation, including but not limited to the address and sequence number of each image segment, the size of each segment, and the total number of segments in the image file. This type of request is designed to divide large image files into multiple small parts for transmission, thereby improving transmission efficiency and reducing network bandwidth pressure. It can also effectively reduce the impact on the entire image when a single segment is lost or erroneous. The system needs to parse each piece of information in these requests to prepare for the subsequent image segmentation processing.

[0033] After receiving an asynchronous image transfer request, the system will first parse all key information in the request. The specific steps are as follows: Segment Address Resolution: The system first prepares the receiving location for each image segment based on the segment address information in the transmission request. Each segment is stored separately at a designated location, ensuring that each segment is correctly located and stored at the receiving end during transmission.

[0034] Segment Sequence Number Processing: The segment sequence number information in the request allows the system to correctly sort and organize each segment during the reception process. The segment sequence number helps the system confirm the order of each segment received, thus ensuring the correct order of the image files when merging. The sequence number information is usually an increasing number to ensure the uniqueness of each segment.

[0035] Segment size confirmation: The system analyzes the size of each segment and uses this size to determine whether special processing is required during storage, such as memory optimization, storage allocation, or cache control. The size of image segments influences both storage memory allocation and flow control strategies during transmission. The system must ensure that each segment size matches the network transmission bandwidth to avoid transmission delays caused by overly large segments or inefficient storage and transmission due to undersized segments.

[0036] Total Segment Count Verification: The system records the total number of segments in the entire image file based on the total segment count information in the request. This information is crucial for the system to monitor image transfer progress and verify image file integrity. The system compares the received segment count with the total number of segments to ensure complete image reception and merging.

[0037] Once the segmentation information is parsed, the system will receive and store the image segments based on this information. At this time, the system will process each segment as an independent data unit, and will use corresponding algorithms and processing logic during the storage process to ensure efficient reception and storage of the segments: Receiving and storing segments: Image segment reception is typically implemented through multi-threading, with each thread responsible for processing a segment. The storage address of each segment is determined by the parsed segment address. Multi-threaded storage can improve the speed of image segment reception and storage, reducing overall transmission time. During the storage process, the system can verify the received segments to ensure transmission accuracy.

[0038] Storage logic control: When receiving image segments, the system will schedule them appropriately based on network conditions and system resources. For example, when network bandwidth is sufficient, the system will increase the number of storage threads and improve storage concurrency; conversely, when network bandwidth is insufficient, the system may reduce the number of threads to maintain a reasonable storage speed and avoid overload. Each thread must maintain the order of the segments during storage to ensure that the image segments are stored in the correct order and in the intended location. The storage logic is as follows: Determine if a segment has been received: Each time a segment is received, the system checks the segment's sequence number to determine if it has been received before. If it has, the system skips storing the segment to avoid duplicate storage.

[0039] Confirmation of successful storage: Each time a segment is successfully stored, the system will mark it as a confirmation, indicating that the segment has been successfully stored. After all segments are stored, the system will prepare for the final merge.

[0040] Error handling and retransmission mechanism: If anomalies such as network interruption, data loss, or storage failure occur during the storage process, the system will initiate a retransmission mechanism based on a pre-set retransmission strategy. Typically, if a received segment is not stored or acknowledged within a certain period of time, the system will request the upload of that segment again. The retransmission mechanism can determine the necessity of retransmission based on the segment sequence number and timestamp.

[0041] Through the above steps, the system can efficiently handle the segmented reception and storage of image files, ensuring that each segment is correctly stored and its order is maintained during the transmission process. This process not only improves the efficiency of image transmission, but also provides a reliable foundation for subsequent image merging and display. Specific examples are as follows: Suppose the front-end is transmitting an image file with a total size of 100MB, divided into 10 segments for upload, each of which is 10MB in size. Upon receiving an asynchronous image transfer request, the system parses each segment's address, sequence number (1 to 10), size (10MB), and total number of segments (10). After receiving the segments, the system uses multi-threading technology to store each segment separately. During storage, the system maintains the correct order of the images based on the segment sequence numbers. Once all 10 segments have been successfully stored, the system initiates a merge request, beginning the image merging process and ultimately generating the complete 100MB image file.

[0042] In this way, the system can handle the transmission of large-scale image files and ensure the efficient storage and security of image data in different environments and network conditions.

[0043] The system's image storage deployment type determines whether to enable parallel storage. If the deployment type allows, the system will store each segment in parallel based on its size to improve storage efficiency. The system will process multiple segment files until all segments are stored.

[0044] During image storage, the system determines whether to use parallel storage based on the storage deployment type. Parallel storage is an effective solution for improving storage efficiency in large-scale image transmission, particularly when dealing with high-resolution image files and high concurrency requirements. The system's storage deployment type determines whether parallel storage is supported. When supported, the system dynamically allocates storage resources based on the size of each image segment and processes multiple segment files in parallel, significantly improving image storage efficiency.

[0045] During the image segmentation storage process, the system first needs to determine the image storage deployment type. The storage deployment type is usually determined by factors such as server configuration, storage resource availability, and network bandwidth. Common storage deployment types include: Single-server storage: Both storage and data processing are performed on the same server. This type of deployment is suitable for small-scale image storage needs and usually does not involve parallel storage.

[0046] Multi-server storage: Storage and data processing are distributed across multiple servers. This deployment type provides higher throughput and storage capacity, making it suitable for large-scale image storage and parallel processing needs.

[0047] Cloud storage: Image data is stored on the cloud platform and relies on the resources provided by the cloud service for segmented storage and processing.

[0048] Single-server storage: If the system determines that the current deployment is single-server storage, all image segments must rely on single-threaded storage. In this case, the system cannot enable parallel storage, and all segments will be stored sequentially within a single thread.

[0049] Multi-server storage: If deployed with multiple servers, the system uses parallel storage mode, assigning different threads or servers to process different image segment files. The system determines how to allocate storage tasks based on the size of each segment and the current server load.

[0050] When the storage deployment type supports parallel storage, the system starts to allocate storage based on the size of each segment and improves storage efficiency through parallel computing. The specific steps are as follows: The system first analyzes the storage requirements of each image segment based on its size. Larger segments may require more storage resources (such as memory and bandwidth), while smaller segments can be stored quickly. The system dynamically allocates storage tasks based on segment size to avoid bottlenecks in the storage of certain segments, which could delay the storage of other segments. The system first reads the segment information to determine the size of each segment. Each segment is then assigned to a different storage thread or server, ensuring that each storage unit can work in parallel.

[0051] In multi-server storage, the system intelligently allocates storage tasks based on server load and image segment size. Specifically, tasks are assigned according to the following principles: Larger image segments are assigned to servers with greater computing and storage resources to ensure resource-neutral processing speed. For smaller segments, multiple segments can be assigned to the same storage thread or server to improve resource utilization. The system determines the storage thread for each segment based on server availability and network bandwidth. Each thread simultaneously processes storage tasks for one or more segments until all segments are completed.

[0052] The system launches multiple storage threads in parallel, each independently processing a segment's storage operation. Threads are independent of each other and do not block each other when performing storage operations, significantly improving storage throughput. The storage threads write segmented data to the storage device sequentially, with the system's scheduler managing the threads' scheduling.

[0053] Each thread performs the storage task and stores the segmented data in the designated storage location in real time. The system will periodically check the storage progress to ensure that the storage task of each segment is completed. When all segment storage is completed, the system will confirm the storage status based on the return result of each storage thread. If all storage threads return a successful result, the system will mark the image segment storage process as complete and enter the subsequent merging phase. The system checks the storage results of each thread to confirm whether the storage is successful. If all segments are stored successfully, the system generates a storage execution result and sends feedback to the front end. During the parallel storage process, the system also uses some optimization strategies to improve efficiency and avoid resource waste: Load balancing: The system dynamically adjusts the allocation of storage threads based on the load of each storage task, preventing overload on certain servers and causing storage delays. The load balancing algorithm ensures a relatively even workload across each storage unit, improving storage efficiency.

[0054] Bandwidth optimization: In multi-server storage scenarios, the system adjusts data transmission priorities based on network bandwidth availability, ensuring that high-priority storage tasks are processed first when network bandwidth is high, avoiding storage delays caused by bandwidth bottlenecks.

[0055] Resource scheduling and dynamic adjustment: The system dynamically schedules storage resources based on real-time monitoring data. When it finds that the resource usage of a storage thread or server is too high, the system automatically adjusts the allocation of storage tasks, optimizes the storage process, and avoids overload.

[0056] Suppose the system needs to store a large image file that is divided into 100 segments of unequal size. In a multi-server storage deployment, the system first dynamically determines which segments should be assigned to which server based on the size of each segment and the server load. Larger segments may be assigned to servers with more resources, while smaller segments are assigned to servers with lighter loads. The system will store these segments in parallel using multiple threads and confirm the completion of each segment storage. When all segments are stored, the system notifies the front-end that the image storage task is complete and enters the subsequent image merging and display phase.

[0057] In this way, the system can effectively improve storage efficiency and reduce image storage time, especially when processing large-scale image files, ensuring that the storage process is fast, stable and efficient.

[0058] Based on the asynchronous image transfer request received, the image file's storage requirements are analyzed again, initiating the segmented storage process. If the server and file storage service are deployed on the same server and are not limited by network bandwidth, serial storage is used. If the data processing and storage services are deployed on different servers, parallel storage is performed based on network bandwidth and the preset storage size. This ensures that each image segment is stored without delay and synchronized with the front-end request during the storage process.

[0059] During image transmission and storage, upon receiving an asynchronous image transfer request, the system performs a secondary analysis based on the request content, assesses the image file's storage requirements, and initiates the corresponding segmented storage process. The core goal of this process is to ensure that each image segment is stored quickly and without delay, while also ensuring that the storage process is synchronized with the front-end request to avoid any delays or errors during storage. The system determines whether to use serial or parallel storage based on different deployment environments (such as server deployment type) to optimize storage efficiency.

[0060] When the front-end sends an asynchronous image transfer request, the system first parses the request content, extracting information such as the image segment address, sequence number, segment size, and total number of segments. This information is crucial for subsequent storage. The system then performs a secondary analysis based on this information to determine storage requirements and storage strategies. The specific analysis process is as follows: The system extracts detailed information about each image segment from the front-end request and ensures that each segment's order, size, and storage location are processed accurately. For example, the system checks the size of each segment to ensure it does not exceed the storage system's maximum storage limit. The system also determines the storage strategy (serial or parallel) based on the segment size.

[0061] Based on the image segmentation information, the system evaluates the resources required for storage (such as storage space, bandwidth, and server resources). If the image file is large and the network bandwidth is sufficient, the system may choose parallel storage; conversely, if the image file is small or bandwidth is limited, a serial storage strategy may be used.

[0062] The system determines whether to use parallel storage based on the storage service deployment type. If the server and storage service are deployed on the same server and network bandwidth is not limited, the system uses serial storage. If the storage service and data processing service are deployed on different servers and bandwidth is limited, the system uses parallel storage based on network bandwidth and segment size.

[0063] After a secondary analysis of storage requirements, the system initiates the image segment storage process and decides whether to use serial or parallel storage based on the previous analysis. This process ensures that image segments are successfully stored in the shortest possible time and are synchronized with front-end requests during the storage process. The specific steps are as follows: 1) Serial storage (single-server deployment)

[0064] When the server and storage service are deployed on the same server, the system is not limited by network bandwidth and chooses to use serial storage for image segmentation. In this mode, the system will process each segment in turn to ensure that the segment storage is completed in order. The processing logic of the storage process is as follows: Process segments one by one: The system receives and stores each image segment in sequence according to the segment number in the front-end request. Each segment will go through an independent storage process until all segments are stored.

[0065] Single-threaded storage: Because the system's storage services and data processing are deployed on the same server, storage tasks are executed by a single thread. After each storage task is completed, the system confirms that the segment has been successfully stored and continues processing the next segment.

[0066] Progress synchronization: The system will synchronize the storage progress of each segment to the front-end in real time as it stores it, ensuring that the front-end can monitor the entire image transmission and storage process. If a segment fails to be stored, the system will trigger a retransmission mechanism and re-request the upload of that segment.

[0067] 2) Parallel storage (multi-server deployment)

[0068] When data processing and storage services are deployed on different servers, the system performs parallel storage based on network bandwidth and storage pre-set size. During this process, multiple storage threads or servers will process different image segments in parallel, significantly improving storage speed. The specific processing logic is as follows: Allocating storage tasks: The system dynamically allocates storage tasks based on network bandwidth and segment size. Larger segments are assigned to servers with greater bandwidth or processing power, while smaller segments can be assigned to servers with less resource. The system also adjusts storage task allocation based on server load to ensure load balancing.

[0069] Multi-threaded storage: On each server, the system launches multiple threads to concurrently process the storage of image segments. Each thread is responsible for storing one or more segments and returns the results after storage is complete. This simultaneous execution of multiple threads significantly improves storage efficiency.

[0070] Synchronization of storage tasks: The system ensures that threads working on different segments do not interfere with each other, and that all storage operations are performed in the correct order during the final merge step. After each segment is stored, the system records the storage status and synchronizes the current storage progress with the front-end.

[0071] Bandwidth Management and Optimization: In parallel storage mode, the system dynamically adjusts storage task priorities and resource allocation based on actual network bandwidth availability. For example, if bandwidth bottlenecks occur on a particular server, the system adjusts storage task allocation to avoid bandwidth overload during storage, which could impact storage in other segments.

[0072] During the entire storage process, the system ensures synchronization between the storage process and the front-end request to avoid storage delays. The following are the specific steps to ensure synchronization and no delays: The system provides real-time feedback on the storage progress of each segment to the front-end, ensuring that the front-end can monitor the entire image transfer and storage process. Once storage is complete, the system sends a confirmation message to the front-end indicating that all segments of the image file have been successfully stored.

[0073] If a segment fails to be stored during storage, the system immediately initiates a retransmission mechanism to ensure that the unsuccessful segment is replenished in a timely manner. Retransmission requests are made based on the segment sequence number to ensure data integrity.

[0074] When all segments are stored, the system will send a "storage completed" confirmation signal to the front end, indicating that all image files have been stored in the designated location and are ready to enter the image merging stage.

[0075] Suppose the front-end is transmitting a 100MB image file, which is divided into 10 segments, each 10MB in size. In a single-server deployment, the system will store each segment sequentially, with only one thread processing each segment, and only after each segment is processed will the next be stored. In a multi-server deployment, however, the system dynamically allocates storage tasks based on network bandwidth and the size of each segment. Larger segments may be assigned to servers with greater bandwidth, allowing multiple segment storage tasks to be processed in parallel, thus accelerating the storage process.

[0076] Through this process, the system ensures that image segments are stored without delay and are completed synchronously with front-end requests. Whether serial or parallel storage is used, the system can make the optimal storage decision based on the deployment type and network conditions.

[0077] The storage process is monitored in real time, the progress of each storage thread is calculated, and the storage results are compared with the image transfer request from the front-end. When all segmented files are successfully stored, the system generates an image storage execution result and sends it to the front-end. If any anomalies occur during the storage process, the system automatically adjusts the storage strategy accordingly to ensure image data integrity and transfer efficiency.

[0078] During the segmented image storage process, to ensure smooth storage, the system monitors the progress of each storage thread in real time and adjusts the storage strategy based on real-time feedback. This process not only ensures the efficiency and stability of the storage process, but also ensures the integrity and transmission efficiency of the image data. Once all segmented files are successfully stored, the system generates the image storage execution results and feeds them back to the front-end. If any anomalies occur during the storage process, the system automatically adjusts based on the specific situation to prevent any factors that may affect image integrity. The following are the detailed steps of the entire real-time monitoring and storage process: The system tracks the progress of each storage thread in real time, ensuring that each thread processes the corresponding image segment as planned. As each storage thread stores an image segment, it reports its current status to the system, including the number of bytes stored, completed storage tasks, and the estimated completion time. The system collects this information and aggregates it in the background to ensure that the overall storage process remains on track.

[0079] When each thread begins storing data, the system assigns it a unique identifier (ID) and records the start time. During the storage process, the system periodically monitors each thread's progress and calculates the ratio of completed stored bytes to the total number of bytes stored. Based on each thread's feedback, the system calculates the completion percentage and uses this information for subsequent adjustments or optimizations to the storage process.

[0080] During monitoring, the system regularly reports storage progress to the front-end, ensuring real-time visibility into image storage status. This progress typically includes the number of segments stored, the current storage progress (percentage), and the remaining storage time. The front-end displays a storage progress bar or other progress indicators based on this information to ensure a smooth user experience.

[0081] The system calculates the total amount of storage completed based on the progress information of each storage thread. Whenever new progress data is generated, the system sends the current progress (including the completion percentage of each segment) to the front-end. The system compares the storage progress information with the segment information of the image transfer request to ensure that the status of each segment storage is consistent with the progress requested by the front-end.

[0082] After the storage process is complete, the system compares the storage results of each thread. By comparing the segment sequence number and size with the front-end transmission request, the system verifies the successful storage of each segment and confirms the integrity of the image data. The comparison results directly influence subsequent operations. If any anomalies are found, the system will immediately adjust the storage strategy.

[0083] The system first checks the storage results for all segments to ensure that each segment has been successfully stored and meets the requested size. The system verifies the storage success by comparing the actual number of bytes stored with the expected segment size. If the segment size does not match or the storage time is abnormal, the system triggers an exception handling mechanism. Once all segments have been successfully stored, the system generates a storage execution result and feeds it back to the front-end, confirming that the entire image file has been successfully stored.

[0084] During the storage process, the system monitors the storage status of each thread in real time to detect any anomalies. For example, if a segment storage times out, fails, stalls, or experiences a network outage, the system immediately identifies the issue and triggers an exception handling process.

[0085] The system checks the running status of the storage thread, such as whether there are any storage thread timeouts, failures, or deadlocks. If a storage failure or abnormal progress is detected, the system will immediately mark it as an abnormality and take appropriate measures based on the abnormality type (such as timeout, error, network interruption, etc.).

[0086] If an exception occurs, the system automatically adjusts storage policies to ensure image data integrity and transmission efficiency. Specific adjustment policies may include re-requesting failed segments, adjusting storage thread priorities, restarting storage processes, or reallocating storage tasks based on bandwidth.

[0087] If a segment fails to be stored, the system automatically retries until the maximum number of retries is reached or until success occurs. If bandwidth bottlenecks occur during storage, the system dynamically adjusts the number of storage threads based on the current bandwidth limit and prioritizes smaller segments. The system monitors network conditions in real time and automatically decides whether to adjust storage resource allocation or re-plan storage strategies to ensure optimal storage performance.

[0088] After all segments are successfully stored or exceptions are handled, the system generates an image storage execution result. If the storage is successful, the system returns a "successfully stored" status and sends it to the front-end. If there are any exceptions during the storage process, the system generates a "storage failed" or "partially successful" status and notifies the front-end of the specific failure information or a retransmission request.

[0089] After all segments are stored, the system generates an image storage execution result, including information about successful storage, storage failure, or partial success. This result is fed back to the front-end, providing detailed status and progress to help the front-end understand the storage status and take further action.

[0090] Suppose the system is storing an image file divided into 20 segments, each 10MB in size. During the storage process, the system monitors the storage progress of each segment in real time and reports the current storage progress to the front-end every 5 seconds. If an exception occurs while storing the 15th segment (for example, a network disconnect), the system immediately detects this anomaly and triggers a retransmission mechanism, requesting that segment be uploaded again. If the retry succeeds, the system continues to store the remaining segments. Once all segments have been stored, the system reports the storage execution result to the front-end, notifying the front-end that the image storage has successfully completed.

[0091] Through this mechanism of real-time monitoring, comparison of storage results, exception handling and adjustment of strategies, the system can effectively guarantee the integrity, efficiency and reliability of image storage, and ensure that the user experience is not affected by potential problems in the storage process.

[0092] After all image segment files are stored, the front-end receives an image merge request. This request is generated based on the storage execution results. The front-end uses this request to notify the server to start merging the stored image segments. After the system confirms the merge request, the image merging process begins.

[0093] After all the image segment files are stored, the system will receive an image merge request from the front-end. This request is generated based on the results of the previous storage execution. The front-end notifies the server through this request to start the image segment merging process. The arrival of the merge request means that all image segments have been successfully stored. After receiving the merge request, the system needs to perform subsequent image merging operations to restore the complete image file. The image merging process not only requires ensuring the correct order of the segments, but also the integrity and quality of the image file. The following are the detailed steps of the image merging process: After receiving the merge request from the front-end, the system first needs to verify the request to confirm that all segment files have been successfully stored and that the segment numbers in the request are consistent with the storage order. This process ensures that the merge operation requested by the front-end is reliable and executable.

[0094] The system verifies the merge information in the request, such as the total number of segments, the sequence number of each segment, and the file storage path. It confirms that the number of segment files listed in the request matches the number of stored segments and checks the storage status of each segment to ensure that all segments have been successfully stored and are available for merging. If any segment files are missing or incompletely stored, the system returns an error message, prompting the front-end to resend the merge request.

[0095] Based on the merge request, the server merges multiple segmented files to generate a complete HD image file. During the merging process, the system will ensure that the merged image is seamlessly connected and maintains image integrity and quality based on the order of stored files and image segmentation information.

[0096] Once the merge request is successfully verified, the system initiates the image merging process. This involves merging all segmented files into a single, complete image file in the correct order. To ensure the correct merging of the images, the system strictly stitches each image segment according to the segment sequence number and performs necessary error detection and validation.

[0097] The first step in the merge process is to ensure that each image segment is in the correct order. The system checks that the order of each segment is consistent, based on the segment sequence number in the request and the stored result. If the order is incorrect, the merge operation may result in a corrupted or invalid image.

[0098] The system sorts all stored segment files by segment sequence number. The system checks that each segment's sequence number matches its storage location to ensure the correct order. If any errors are found, the system stops the merge and notifies the front-end.

[0099] The system reads each image segment in the sorted order and merges them. To ensure image integrity, the system uses a step-by-step approach during the merging process, writing the data blocks of each segment file into the target image file in sequence.

[0100] The system opens the target image file and allocates sufficient storage space. The system reads the segmented file one by one, sequentially writing each segment's data blocks to the target file. After reading each segment, the system checks whether the write operation was successful. If the write operation fails, the system aborts the merge and rolls back the completed operation. During each segment merge, the system performs data verification to ensure that each data block is written correctly and prevents data corruption or loss.

[0101] During the merge process, the system needs to verify the integrity of each data block to ensure that the image merge operation has not caused any errors. If data corruption or inconsistency is detected during the merge process, the system will perform error handling and retry the merge operation.

[0102] During the merge process, the system verifies the data integrity of each segmented file using hash values, checksums, or other data verification algorithms. While writing to the target image file, the system periodically checks whether the hash value of the current image data block is consistent with the expected value. If the verification fails, the system immediately stops the current operation and prompts the front-end to retry.

[0103] Once all segmented files are successfully merged, the system will perform a final verification of the resulting complete image file to ensure its usability and integrity. After the merge is completed, the system will feedback the merge success result to the front-end and notify the front-end that the image file has been successfully restored.

[0104] The system checks the size, format, and other metadata of the merged image files to ensure the merged result meets expectations. The system generates a merge execution result and returns it to the front-end, notifying it of the image merge completion. If there are no errors during the merge, the system sends a "Merge Successful" status notification. If any errors occur during the merge, the system returns an error message and asks the front-end to retry.

[0105] During the image merging process, the system may encounter various anomalies, such as insufficient storage space, file corruption, incorrect segmentation order, etc. To improve the robustness of the merging process, the system will implement an automatic retry mechanism and perform timely anomaly detection and processing during the merging process.

[0106] If the system detects insufficient storage space during a merge, it will temporarily halt the merge and notify the front-end to expand storage space or adjust storage settings. The system can estimate the space required to complete the merge based on the current free space and make dynamic adjustments.

[0107] If a file is damaged or missing when reading an image segment, the system will immediately stop the current merge operation, log the error information, and notify the front-end. The system can enable a retry mechanism to request the front-end to re-upload the missing or damaged segment.

[0108] If the system detects that the image segments are out of order, it stops the merge process and prompts the front-end to check the segment sequence numbers. The system checks whether the stored sequence numbers of each segment are consistent with the sequence of the segments in the request.

[0109] Suppose the front-end transmits an image file and divides it into 10 segments. The system receives a merge request after storing all the segments. The system will first verify that all the segments are stored and in the correct order, and then start merging according to the segment order. When the system reads the 5th segment and writes it to the target image file, the system checks the integrity of the written data to ensure that no data is damaged or lost. If all segments are in the correct order and the data is complete, the system generates a merge success result and notifies the front-end that the merge is complete. If a segment file is detected to be missing during the merge process, the system stops the merge operation and asks the front-end to re-upload the segment.

[0110] Through this merging process, the system ensures that the image files can be restored accurately and completely, and at the same time guarantees the efficiency and reliability of the image merging process through the exception handling mechanism.

[0111] After the images are merged, the system further optimizes the merged image based on real-time feedback and display requirements. This includes automatically adjusting image parameters such as brightness, contrast, and color saturation to meet the requirements of the naked-eye 3D display system. The system adjusts the image display based on the display system configuration and viewer position to ensure the best 3D effect.

[0112] After the images are merged, the system needs to further optimize the merged image to meet the requirements of the naked-eye 3D display system and provide the best viewer experience. Naked-eye 3D display technology requires that the image not only have a sense of spatial depth, but also provide sufficient visual clarity, contrast, and color depth to enhance the sense of three-dimensionality and immersion. To achieve this effect, the system automatically adjusts image parameters such as brightness, contrast, and color saturation based on real-time feedback and display requirements, and optimizes according to the display system configuration and viewer position.

[0113] Image brightness and contrast are crucial factors influencing the quality of naked-eye 3D displays. Brightness controls the degree of brightness in the image, while contrast determines the difference in the depth of the image. To ensure a clear, vibrant 3D effect under varying viewing conditions, the system adjusts these parameters based on the real-time environment and display requirements.

[0114] Brightness Adjustment: The system first adjusts the image's brightness based on the ambient light and the display system's brightness requirements. Ambient light fluctuations can cause the image to appear too dark or too bright, affecting the 3D effect. Therefore, the system compensates for brightness based on the current ambient light intensity (e.g., the lighting at the viewer's location).

[0115] Contrast Adjustment: To enhance the depth of the image, the system adjusts contrast based on the image content and 3D display requirements. Too low a contrast ratio can result in loss of image detail, while too high a contrast ratio can cause image distortion. Therefore, the system automatically adjusts contrast based on preset optimal display effects.

[0116] The system can use the following optimization algorithm to adjust the brightness and contrast of the image. The brightness adjustment formula is: ,in, is the brightness gain factor, is the brightness offset, is the original brightness value, The brightness gain factor is used to adjust the brightness of the image. It is usually calculated dynamically based on the ambient light intensity, the brightness configuration of the display system, and the relative position of the viewer to the display. This factor determines how to increase or decrease the brightness of the image according to the light intensity. The brightness gain factor value is generally between 1.0 and 2.0. Lower values ​​will make the image darker, while higher values ​​will make the image too bright. Dynamic calculation of the brightness gain factor: ,in, is the current ambient light intensity, is the minimum ambient light intensity, It is an adjustment coefficient, usually with a value between 0.1 and 0.5.

[0117] Contrast adjustment formula: ,in, is the contrast adjustment factor, is the original contrast value, The contrast adjustment factor determines the brightness and darkness of the image, affecting the image's depth perception. In naked-eye 3D displays, contrast adjustment needs to consider the display device's brightness range and the viewer's distance and angle. Typically, the contrast factor is between 1.0 and 1.5. Dynamic calculation of the contrast adjustment factor: ,in, is the distance between the audience and the display screen, is the maximum allowed distance, This is an adjustment factor, usually ranging from 0.1 to 0.3, to ensure consistent image contrast at different viewing angles.

[0118] Color saturation determines the vividness of an image's colors. Too low a saturation makes the image appear dull, flat, and lacking depth; too high a saturation can cause color distortion, affecting the visual experience. In glasses-free 3D displays, to ensure natural, realistic colors without losing the sense of three-dimensionality, the system adjusts the image's color saturation based on the display device's color rendering capabilities and the viewer's position.

[0119] The system adjusts color saturation based on the image's visual perception requirements and the display environment. This adjustment not only takes into account the characteristics of the display system but also considers changes in the current ambient light to avoid over-saturation or under-saturation. The following formula is used to adjust the image's saturation: Saturation adjustment formula: , where S is the color saturation of the image, is the saturation adjustment factor, is the original saturation value, The saturation factor is the adjusted value. Saturation determines the vividness of the image color. The system adjusts it based on the ambient light and the color performance of the display device. Too high a saturation will make the color too vivid and unnatural, while too low a saturation will make the image appear gray. The saturation factor is generally set between 0.8 and 1.5. The dynamic calculation of the saturation adjustment factor is: ,in, is the current ambient light intensity, is the minimum ambient light intensity, It is an adjustment coefficient, usually with a value of 0.1 to 0.3, to ensure that the image color remains consistent in different environmental conditions.

[0120] To further optimize the image display, the system also needs to adjust the image's display based on the viewer's position. Glasses-free 3D displays require the image's parallax to dynamically adjust based on the viewing angle to enhance the 3D experience. The system detects the viewer's position through sensors or cameras and adjusts the image's parallax and angle accordingly.

[0121] Parallax adjustment: Based on the relative position of the viewer and the display screen, the system can dynamically adjust the parallax of the image, allowing the viewer to see different image details from different angles, thereby enhancing the three-dimensional effect. The system calculates the appropriate parallax value by monitoring the viewer's position and angle in real time. Based on the relative distance between the viewer and the display screen, it calculates the parallax adjustment value for each image segment and dynamically adjusts the image display effect.

[0122] Angle optimization: Depending on the audience's viewing angle, the system may adjust the brightness, contrast, and saturation of the image to ensure consistent image quality at different viewing angles.

[0123] The system continuously optimizes the image based on real-time feedback from the display. By continuously monitoring audience feedback (such as the user's head position and visual perception), the system can adjust various image parameters (brightness, contrast, color saturation, etc.) in real time to ensure the best possible naked-eye 3D display.

[0124] The system regularly collects data on ambient light and viewer position and adjusts image display parameters based on this information. Based on viewer feedback (such as visual comfort and 3D effect perception), the display is adjusted in real time to ensure that every viewer in their respective position has the best viewing experience.

[0125] Finally, after optimizing brightness, contrast, and saturation, the system generates an adjusted image file and prepares it for transmission to the display device. In a glasses-free 3D display system, the image optimization step ensures that every detail of the image is accurate and immersive, tailored to the display device's capabilities and the viewer's actual viewing needs.

[0126] The system transmits the combined and optimized image data to the display device via the appropriate interface or protocol, ensuring accurate image presentation on each device. It also monitors any anomalies during the display process to ensure consistent image stability and meet the quality requirements of naked-eye 3D displays.

[0127] Imagine a large exhibition setting where the system has already merged and optimized the images. Depending on the viewer's position, the image's brightness and contrast will adjust further away from the display to ensure a moderate brightness. Simultaneously, the color saturation of the image as seen from different angles is optimized based on real-time feedback from the system. If the colors in certain areas are oversaturated, the system automatically reduces the saturation to ensure a natural and realistic image from all angles.

[0128] Through these steps, the system ensures that various image parameters such as brightness, contrast, color saturation and parallax match the requirements of the naked-eye 3D display system, thereby providing high-quality visual effects and three-dimensional perception, and enhancing the user's immersive experience.

[0129] Throughout this specification, references to terms such as "one embodiment," "example," or "specific example" indicate that the specific features, structures, materials, or characteristics described in conjunction with that embodiment or example are included in at least one embodiment or example of the present invention. In this specification, schematic representations of these terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in any one or more embodiments or examples.

[0130] The preferred embodiments of the present invention disclosed above are intended only to help illustrate the present invention. These preferred embodiments do not exhaustively describe all details, nor do they limit the present invention to specific embodiments. Obviously, many modifications and variations are possible based on the contents of this specification. These embodiments are selected and described in detail in this specification to better explain the principles and practical applications of the present invention, thereby enabling those skilled in the art to better understand and utilize the present invention. The present invention is limited only by the claims and their full scope and equivalents.

Claims

1. A method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building, characterized by: The display method comprises the following steps: The display system receives an asynchronous image transmission request from the front end and starts the transmission process after responding to the request, the request including segmentation information of the image file; Determine whether to perform parallel storage based on the image storage deployment type of the display system. Based on the received asynchronous image transfer request, analyze the image file storage requirements again and start the segmented storage process. Monitor the storage process in real time, calculate the work progress of each storage thread, compare the storage results with the front-end image transmission request, and generate the corresponding storage strategy based on the comparison results; After all the image segment files are stored, the server receives an image merging request from the front end, starts the image merging process, and merges multiple segment files to generate an image file; After the image merging is completed, the parameters of the merged image are automatically optimized according to real-time feedback and display requirements, and the image display effect is adjusted in real time according to the display system configuration and the audience position.

2. The method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building according to claim 1, characterized in that: After the image merging is completed, the parameters of the merged image are automatically optimized based on real-time feedback and display requirements, including the following steps: Automatically adjust image brightness, contrast, and color saturation parameters based on real-time feedback and display requirements; Compensate for brightness based on the current ambient light intensity, adjust contrast based on image content and 3D display requirements, and adjust image color saturation based on the color rendering capabilities of the display device and the viewer's position.

3. The method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building according to claim 2, characterized in that: Adjust the image display effect in real time based on the display system configuration and viewer position, including the following steps: By monitoring the audience's position and angle in real time, the parallax value is calculated. According to the relative distance between the audience and the display screen, the parallax adjustment value of each image segment is calculated, and the image display effect is dynamically adjusted; Adjust the brightness, contrast, and saturation of the image based on your audience's viewing angle.

4. The method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building according to claim 3, characterized in that: Start the image merging process. The server merges multiple segmented files to generate an image file. The process includes the following steps: Read each image segment in sequence according to the sorted order and merge them. In the merging process, a step-by-step splicing method is adopted to write the data blocks of each segment file into the target image file in sequence. After all segmented files are successfully merged, the size, format, and other metadata of the merged image file are checked, the merge execution result is generated, and returned to the front end to notify the front end that the image merge is complete.

5. The method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building according to claim 4, characterized in that: Monitor the storage process in real time, calculate the work progress of each storage thread, compare the storage results with the front-end image transmission request, and generate the corresponding storage strategy based on the comparison results, including the following steps: Track the progress of each storage thread in real time, including the number of bytes stored, completed storage tasks, and estimated completion time; When each thread starts storing data, a unique identifier is assigned to the thread and the start time is recorded. During the storage process, the work progress of each thread is periodically obtained, and the ratio of the number of completed stored bytes to the total number of bytes is calculated. After the storage process is completed, the storage results of each thread are compared with the segment sequence number and size in the front-end transmission request to verify whether each segment is successfully stored; If a storage anomaly occurs, the storage policy will be automatically adjusted, including re-requesting failed segments, adjusting storage thread priorities, restarting storage processes, or reallocating storage tasks based on bandwidth.

6. The method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building according to claim 5, characterized in that: Based on the received asynchronous image transfer request, the storage requirements of the image file are analyzed again and the segmented storage process is started, which includes the following steps: When the front end sends an asynchronous image transmission request, it extracts information including the image segment address, sequence number, segment size, and total number of segments; Extract each image segment information from the front-end request and determine the storage strategy based on the segment size, including parallel storage and serial storage; If the server and storage service are deployed on the same server and the network bandwidth is not limited, serial storage is used; If the storage service and data processing service are deployed on different servers and there is bandwidth limitation, parallel storage is performed based on the network bandwidth and segment size; After the secondary analysis of storage requirements is completed, the image segmentation storage process is started.

7. The method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building according to claim 6, characterized in that: The serial storage strategy includes the following steps: Receive and store each image segment in sequence according to the segment sequence number in the front-end request. Each segment will go through an independent storage process until all segments are stored. After each storage task is completed, confirm that the segment is stored successfully and continue to process the next segment; When storing each segment, the storage progress is synchronized to the front end in real time. If a segment storage fails, the retransmission mechanism is triggered and the upload of the segment is re-requested.

8. The method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building according to claim 6, characterized in that: The parallel storage strategy includes the following steps: Dynamically allocate storage tasks based on network bandwidth and segment size; On each server, multiple threads are started to process the image segment storage task in parallel. Each thread is responsible for storing one or more segments and returns the storage results after the storage is completed. After each segment is stored, the storage status is recorded and the current storage progress is synchronized with the front-end; In parallel storage mode, the priority and resource allocation of storage tasks are dynamically adjusted according to the actual network bandwidth.

9. The method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building according to claim 1, characterized in that: Determining whether to perform parallel storage based on the image storage deployment type of the display system includes the following steps: Image storage deployment types for display systems include single-server storage, multi-server storage, and cloud storage: If the current deployment is determined to be single-server storage, all image segments rely on single-thread storage, and all segments are stored sequentially within one thread; If deployed as multi-server storage, enable parallel storage mode and assign different threads or servers to process different image segment files.

10. The method for transmitting and displaying high-definition naked-eye 3D images in a giant spherical building according to claim 9, characterized in that: Receives asynchronous image transmission requests from the front end and starts the transmission process after responding to the request. The request includes the segmentation information of the image file. The segmentation information includes the segment address, segment sequence number, each segment size and the total number of image segments.

Images