CN102722549A - Cluster-based real-time rendering service of remote sensing data set - Google Patents

Abstract

The present invention provides a systematic solution for clustering and fast rendering of multi-source remote sensing data sets, especially for massive remote sensing data and different types of data sets, and solves the problem of distributed organization and storage of data and the combination of multiple data sets Query questions. First, deploy a cluster environment suitable for the real-time rendering system of massive remote sensing data, which is composed of a number of nodes integrating "computing and data" and a central server; the client's tile rendering request is sent to the central server through a network channel, and the latter performs query, screening and processing. processing to obtain the list of visible data within the tile range, and determine the optimal node according to its storage location; the node reads the tile blocks corresponding to each data, superimposes and renders them on the canvas one by one, and sends them back to the central server; finally, the The central server returns the result to the client. The invention is suitable for large-scale application fields such as texture and terrain tile production of two-dimensional/three-dimensional surface rendering, visualization in large-scale remote sensing data management, and the like.

Description

A cluster-based real-time rendering service for remote sensing datasets

technical field

The invention relates to cluster computing technology and remote sensing data visualization technology, in particular to clustered tile data rendering technology of remote sensing data sets. The invention is applicable to the real-time rendering service of massive remote sensing data in the world.

Background technique

The overlay rendering of multi-source remote sensing data generally includes technical processes such as data pyramid construction, tile canvas creation, data reading, and sequential overlay rendering. Among them, the pyramid construction technology has been widely used. For example, ArcSDE of ESRI, GeoImageDB of Wuhan University, and SuperMap of SuperMap software have all realized the pyramid construction technology of images and improved the efficiency of data extraction. However, global data rendering involves issues such as multiple data sources, multi-band data extraction and overlay drawing, data source update and interactive operation, which largely limits the real-time and effectiveness of rendering. Most of the current systems adopt strategies such as pre-rendering and establishing a global data tile index system, such as Google Earth and Skyline software. There are deficiencies in the degree of professionalism and user operation. Related references include ArcSDE-The UniversalSpatial Server for ARC/INFO, An ESRI White Paper, April 1999; Fang Tao, Li Deren, Gong Jianya, Pi Minghong, Development and Implementation of Multiresolution and Seamless Image DatabaseSystem GeoImageDB, Journal of Wu University of Surveying and Mapping, 24(3), 1999; http://earth.google.com/; http://www.skylineglobe.com, etc.

In order to realize the real-time visualization service of large-scale global real remote sensing data, it needs to be supported by a cluster computing environment, which specifically involves key technologies such as cluster management technology, task scheduling technology, and distributed file system. Existing mainstream technologies, cluster management software such as OSCAR, ROCKS, Perceus, xCAT, etc., task scheduling technologies such as LoadLeveler, Gearman, Hadoop, Control Tower, LVS, etc., distributed file systems such as MapReduce, Lustre, etc., all provide cluster computing environmental solutions. However, rendering computing tasks have the characteristics of large network throughput and fine computing granularity, so it is difficult to find a completely suitable technical solution. Related references include http://www.rocksclusters.org; http://xcat.sourceforge.net/; http://hadoop.apache.org/, etc.

The rendering tile request and tile data reply between the client and the cluster nodes need to be transmitted through the network, requiring fast and stable network response and a specific message processing mechanism. MPI provides a standardized network communication mechanism, but it does not support fine-grained and fast-response computing tasks enough. Related references include http://www.open-mpi.org; http://www.mcs.anl.gov/research/projects/mpich2/, etc.

In addition to distributed file storage, the metadata index and corresponding spatial index of remote sensing data need to be established through the database system, so that when the user requests to render tiles, the corresponding data storage location can be quickly retrieved and the optimal location can be determined. calculate node. Databases that currently support or partially support the OGR standard include Oracle, MySQL, PostgreSQL, etc. Related references include http://www.oracle.com; http://www.mysql.com/; http://www.postgresql.org/.

The cluster-based global remote sensing data rendering service system also involves joint query of multiple data sets, fine-grained computing granularity, and fast network response. Currently, it can be seen that there are many independent studies in the literature/patents, but from the perspective of the system as a whole No solution has yet emerged.

Contents of the invention

The purpose of the present invention is to provide a systematic solution for clustering and fast rendering of massive multi-source remote sensing data sets, especially for massive remote sensing data and different types of data sets, to solve the problem of distributed organization and storage of data, multiple Joint query problems of datasets and multi-mode parallel computing problems.

The basic idea of the present invention is as follows: first, deploy a cluster environment suitable for a real-time rendering system of massive remote sensing data, which is composed of several nodes integrating "computing-data" and a central server, and the central server deploys and saves all the meta information of remote sensing data entering the cluster at the same time ; When the client's tile rendering request is sent to the central server through the network channel, the latter performs SQL query and post-processing to obtain the list of rendering data required for the top layer within the tile range, determine the rendering order, and store the data according to the The position determines the optimal node; when the node is rendered, each data file is read, and the data of the range and level of the tile is loaded, superimposed and rendered on the canvas one by one, and sent back to the central server; finally, the central server returns the result.

The technical solution of the present invention provides a cluster-based real-time rendering system for remote sensing data sets, which specifically includes the following implementation steps:

1) Construct a cluster environment, set up several nodes integrating computing and storage, each node includes a multi-core workstation, and mount a storage disk array, connect the nodes with a high-speed local area network; deploy a multi-core server, install a relational database, Connect to each node through a local area network;

2) After the remote sensing data enters the cluster, it will be placed in the storage array of a node as a whole (or placed in multiple nodes in a redundant manner), and its meta information will be extracted at the same time, stored in the database of the server, as Data query conditions;

3) For a tile, its unique number is determined according to the three indicators of viewpoint level, spatial position, and tile size, and the spatial range it represents is also determined;

4) The tile rendering request is sent from the client to the central server through the network. The former establishes a priority mechanism and maintains a request queue, and the latter processes each tile rendering request in parallel in a multi-threaded manner;

5) The server finds the data within the spatial range in all data sets through the database that supports spatial indexing, and then executes the data screening algorithm, sorts the data according to the data set type, time and other rules, and eliminates the data that is covered in the lower layer , that is, the sorted data list to be rendered and its corresponding storage location information are obtained;

6) According to the generated data list, select the node with the most data distribution in the list as the computing node ("computing-data" integration), and assign the rendering task to this node;

7) The rendering process of a tile in the computing node is: create a canvas, read the data blocks in the tile range in sequence according to the order of the data list from bottom to top, set the part without data to transparent, and render it into the canvas;

8) Send the rendered tile data back to the central server, and return it to the client through the central server;

9) Steps 4) to 8) complete the rendering of a single tile, distribute different rendering tasks to each node for calculation, and at the same time perform query operations on the server side and rendering calculations on the node side in a multi-threaded manner, that is, the cluster is realized The optimized parallel rendering process provides real-time rendering services externally.

The above steps are characterized by:

步骤1)、步骤2)部署了一个计算与数据一体化的集群环境，数据作为一个整体进行存储，不同数据分散存储在各个存储节点(同时也是计算节点)中，由中心服务器的关系型数据库统一管理其元信息；实现快速数据查询的同时，便于将计算任务分配到数据所在的节点，对于数据密集型的渲染任务，大大减少了计算时数据的网络吞吐量。

Step 1) and Step 2) deploy a cluster environment that integrates computing and data, and the data is stored as a whole, and different data are scattered and stored in each storage node (also a computing node), and are unified by the relational database of the central server Manage its meta-information; while realizing fast data query, it is convenient to assign computing tasks to the nodes where the data is located. For data-intensive rendering tasks, the network throughput of data during computing is greatly reduced.

步骤4)对于瓦片请求建立优先级缓存机制，优先处理最需要得到的瓦片渲染请求并随时剔除已废弃的请求，提高了实时性。

Step 4) Establish a priority caching mechanism for tile requests, give priority to processing the most needed tile rendering requests and remove discarded requests at any time, improving real-time performance.

步骤5)的数据筛选算法，筛选出了最上层用户能看到的数据列表，剔除了大部分被覆盖在下层的数据，避免渲染时无用的数据读取和绘制操作，节省了计算量和数据吞吐量。

The data screening algorithm in step 5) screens out the data list that the top-level user can see, and eliminates most of the data that is covered in the lower layer, avoiding useless data reading and drawing operations during rendering, saving calculation and data throughput.

步骤5)、步骤6)的数据查询、数据筛选、确定节点过程对于每个瓦片是独立的操作，在服务端以多线程的方式实现任务级并行化；同样，步骤7)的渲染过程也在计算节点端实现了并行化；结合步骤9)所述的整体过程，即为本发明的渲染流程集群实现方式，体现了细粒度任务划分、“计算-数据”一体化和“集群+多核”的多模式并行计算特征。

The data query, data screening, and node determination processes in step 5) and step 6) are independent operations for each tile, and task-level parallelization is realized in a multi-threaded manner on the server side; similarly, the rendering process in step 7) is also Parallelization is realized at the computing node side; combined with the overall process described in step 9), it is the rendering process cluster implementation method of the present invention, which embodies fine-grained task division, "computing-data" integration and "cluster + multi-core" The multi-mode parallel computing feature.

Compared with the prior art, the present invention has the following characteristics: (1) Due to the binding of calculation and data, and the scheduling of calculation tasks driven by data, it can effectively avoid network congestion caused by frequent data network throughput, and fully utilize The efficiency and performance of storage and computing; (2) Centralized storage of data meta-information enables fast query, positioning and screening; (3) Multi-threaded data query and "cluster + multi-core" rendering computing mode form an effective and Unique parallelized real-time rendering pipeline.

Description of drawings

Figure 1 The cluster structure of computing and storage binding

Figure 2 Contents of metadata field of data

Fig. 3 global tile division and numbering method of the present invention

Among them, Figure 3-(1) shows the division and numbering of global tiles at level 0, and Figure 3-(2) shows the division and numbering of tiles at level 1 worldwide;

Figure 4 Parallel rendering process of remote sensing datasets

Figure 5 Rendering request priority definition

Figure 6 Tile request queue cache maintenance process

Figure 7 Schematic diagram of data screening

Figure 8 rendering rendering

Detailed ways

Fig. 1 is the used cluster environment topology of the present invention: the central server installs the MySQL database, manages the meta-information of the remote sensing data in the cluster, and is connected with the cluster nodes by common Ethernet (100M); each cluster node consists of a computing blade and It consists of a disk storage array, and the nodes are connected by high-speed Ethernet (Gigabit). For each remote sensing data in the system, its meta-information includes the following contents (see Figure 2): data set type, data name, acquisition time, effective spatial range of data, storage nodes, and paths. The first four items are used to query the data within the tile space, and the last two items are used to resolve the corresponding storage location and path of the data. Among them, "dataset type" identifies different data types, for example, OrthorLandsatTM5 indicates the orthophoto dataset of TM5; "data name" is the unique identification of the data in the system; "acquisition time" refers to the shooting time of the data ; "valid spatial range of the data" refers to the longitude and latitude coordinate range of the effective image of the data, which is represented by a polygon and stored in the spatial field of the database; "storage node" refers to the number of the storage node where the data is located; "path" refers to The storage path of the data.

When the remote sensing data is stored in the database, it will be classified and stored in nodes according to its spatial range. For example, it will be divided into 8 regions according to the longitude range (-180°～180°), and the data in the same region will be stored in the same node. in a node. Such a strategy can try to ensure that the data that needs to be accessed is stored in the local disk during rendering calculations, reducing network throughput.

Fig. 3 illustrates the tile division method used in the present invention, and the tile size used is 256 pixels × 256 pixels, and the specific division method is as follows:

① Divide the world into 8 tiles with 2 rows and 4 columns according to the latitude and longitude projection (longitude range -180°～180°, latitude range -90°～90°), as level 0 (see Figure 3-(1)) , that is, the visual topmost layer; use a 3-dimensional vector (X, Y, D) to number each tile, X represents the column number of the tile, Y represents the row number of the tile, and D represents the level of the tile ; For example, (2, 1, 0) means the tile of the 2nd column, the 1st row, and the 0th level, and according to the division rules of the 0th level, the geographical range of the tile can be calculated as (longitude 0°～90° , latitude -90°～0°).

② Divide the first-level tiles downwards according to the principle of quadtree, that is, one tile in the 0th level corresponds to 4 tiles in the first level that represent the same geographical range (see Figure 3-(2)), for example (2, 1, 0) tiles at level 0 correspond to (4, 2, 1), (5, 2, 1), (4, 3, 1), (5, 3, 1) at level 1 Four tiles; generally, if a tile is numbered (x, y, d), the corresponding four tile numbers of the next level are:

(2x, 2y, d+1) (2x+1, 2y, d+1) (2x, 2y+1, d+1) (2x+1, 2y+1, d+1)

According to the above rules, the geographical range covered by the tile is:

Longitude range:

Latitude range:

③ According to the above rules, tiles from level 2 to level 19 are numbered. Since the size of the tiles is fixed, the larger the number of layers, the more tiles in this layer, and the higher the pixel resolution. The resulting image is finer.

After the tile numbering rules are determined, the rendering service will be provided in the form of image tiles (see Figure 4). There are three key points in the overall process:

(1) The client maintains the tile request according to the priority strategy (see below);

(2) The central server maintains a cache of tile requests, and processes the requests sequentially in a multi-threaded manner. For each request, after data query, data filtering, and node selection operations, the data list to be rendered for the tile is determined. ;

(3) The rendering node maintains a cache of rendering tasks, and processes the rendering tasks in the cache one by one in a multi-threaded manner, giving full play to the computing efficiency of "calculation-data" integration.

Fig. 5 illustrates the priority variable of the present invention design, and it produces according to certain strategy, specifically follows three principles:

<1> The tiles in the currently activated viewpoint have the highest priority;

<2> Tile requests are decremented according to the order of time they enter the cache, that is, the earlier they enter the cache, the lower the priority;

<3>The rest are user-defined priorities, which are defined according to the vertical tile level and horizontal spatial orientation.

According to the above principles, define a priority value consisting of 24 bits in total. The highest bit indicates the currently activated view point, the middle 18 bits indicate the timestamp, and the last 5 bits indicate the user-defined priority. Wherein, the middle 18 bits will decrement as time goes by, and the request will be removed from the cache until it is 0.

As shown in Figure 6, the priority processing flow of tile requests is as follows:

(1) The client module maintains two queues: the request queue and the rendering list. The request queue maintains all incoming requests when the client calls the request interface, and the request with the highest priority will be sent to the rendering service and entered into the rendering list.

(2) When a new request comes in, if the request already exists in the request queue and the rendering list, it will end and return directly; otherwise, step (3) will be executed.

(3) If the request queue is full, first remove the request with the lowest priority, and then assign a time priority interval value of 3000 to the new incoming request, and put it into the request queue.

(4) Determine whether the maximum number of requests in the rendering list has been reached. If not, send the request with the highest priority in the request queue to the server, remove it from the request queue, and put it into the rendering list; otherwise End returns.

(5) When the rendering result is returned from the server, remove the request from the sent list and return it to the upper layer through a callback, and then perform step (4).

What needs to be explained here is that the rendering list is determined by the rendering capability of the node, and its specific value is:

Among them, Num _max is the maximum number of requests that are rendering the list, n is the number of nodes, and NThread _i is the number of threads used by the i-th node. Among them, the values of n and NThread _i are obtained after the system is started and initialized, and updated in real time. This ensures that the rendering tile request sent to the server is the most needed at present, reflecting real-time performance.

On the central server, all client tile requests will enter the cache queue and be processed in parallel by multiple threads. First, obtain the geographical range of the tile through the calculation formula of "tile number-geographical range" described above; then find out all the covered data in this range in order, and sort them according to the data type and data acquisition time, the rules It is to sort the data types firstly, and then sort the same type of data according to the time from near to far. The data types are sorted according to their resolutions from high to low, and the high resolution is on the upper layer; then and each The effective data range of the data is filtered based on visibility; finally, according to the filtered data list, the node with the most data is selected, and the query results and rendering task information are sent to this node.

In the above query processing flow, the screening principle of the data screening algorithm is shown in Figure 7. The dotted box in the figure is the range of tiles. Assuming that the results of data query and sorting are ①～⑤, then sorted according to the visibility, ⑤ will be eliminated, and ①～④ will be selected as the final data to be rendered.

In the rendering thread of the node, the program obtains the corresponding address from the data list in turn, reads and samples the data fragments within the tile range from the image pyramid, fills the invalid part with transparency, renders it to the canvas, and finally extracts the final Render the result, compress it and send it back to the server, and then return it to the client.

Figure 8 lists the rendering effect of two tiles and the application effect of 2D/3D surface rendering. The tile number in the upper left picture is (380, 67, 7), and the upper layer is SPOT5 with the combination of "near-infrared-red-green" bands Image data, the lower layer is the TM5 image data of the combination of "near infrared-red-green" bands, and its rendering speed is 1353 milliseconds; the tile number of the lower right image is (1521, 262, 9), and the upper layer is the true color QUICKBIRD image Data, the lower layer is the SPOT5 image data of the combination of "near-infrared-red-green" bands, and its rendering speed is 745 milliseconds; the middle picture is the view effect of the 2D client; the bottom picture is the view effect of the 3D client.

The average tile rendering speed of the present invention is within 1 second/tile, and through cluster parallel processing, the average response speed of the tile service is within 80 milliseconds/tile, achieving a real-time effect. The invention is suitable for large-scale application fields such as texture and terrain tile production of two-dimensional/three-dimensional surface rendering, visualization in large-scale remote sensing data management, and the like.

Claims (4)

1. A cluster-based remote sensing dataset real-time rendering service system, characterized in that it comprises the following steps: Step 1: Build a cluster environment, set up several nodes integrating computing and storage, each node includes a multi-core workstation, and mount a storage disk array, connect the nodes with a high-speed local area network; deploy a multi-core server, install and support space retrieval A relational database connected to each node through a local area network; Step 2: When the remote sensing data is entered into the cluster, it will be stored as a whole in the storage array of a single node, or stored in multiple nodes in a redundant manner, and its meta information will be extracted at the same time, stored in the relational database of the server, as Data query conditions; Step 3: For the tile to be rendered, determine its unique number according to the three indicators of viewpoint level, spatial position, and tile size, and the spatial range it represents is also determined; Step 4: The tile rendering request is sent by the client to the central server through the network. The former establishes a priority mechanism and maintains a request queue, and the latter processes each tile rendering request in parallel in a multi-threaded manner; Step 5: The server finds the data list within the spatial range in all data sets through the database that supports spatial indexing, sorts them according to the data set type, time and other rules, and then executes the data screening algorithm to eliminate the data covered in the lower layer , to obtain the top-level data list to be rendered and its corresponding storage location information; Step 6: According to the generated data list, select the node with the most data distribution in the list as the computing node, and assign the rendering task to this node; Step 7: The rendering process of a tile in the computing node is: create a canvas, read the data blocks within the tile range in sequence according to the bottom-up order of the data list, set the part without data to transparent, and render it into the canvas ; Step 8: Send the rendered tile data back to the central server, and return it to the client through the central server; Step 9: Steps 4 to 8 complete the rendering of a single tile, distribute different rendering tasks to each node for calculation, and simultaneously perform server-side query operations and node-side rendering calculations in a multi-threaded manner, which realizes clustering The parallel rendering process provides real-time rendering services externally. 2. The cluster environment according to claim 1, characterized by the integrated deployment of computing and data, different data are scattered and stored in each storage node (which is also a computing node), and its elements are managed uniformly by the relational database of the central server. Information; while realizing fast data query, it is convenient to assign computing tasks to the nodes where the data is located. For data-intensive rendering tasks, the network throughput of data during computing is greatly reduced. 3. The tile request processing mechanism according to claim 1, characterized in that the client establishes a priority cache, prioritizing the most needed tile rendering requests and discarding discarded requests at any time, which improves real-time performance; the central server Through the data screening algorithm, the data list that can be seen by the top-level users is screened out, and most of the data covered by the lower layer are eliminated, so as to avoid useless data reading and drawing operations during rendering, and save calculation and data throughput. 4. The parallel computing according to claim 1, characterized in that the data query, data screening, and node selection processes of the central server are independent operations for each tile, and task-level parallelization is realized in a multi-threaded manner on the server side ; Similarly, the rendering process of the nodes has also achieved task-level parallelization; combined with the overall process of multi-node rendering, the implementation of the clustered rendering process of the present invention is formed, which embodies fine-grained task division, "calculation-data" integration and "Cluster + multi-core" multi-mode parallel computing feature.

Images