CN114661729B - A method and device for generating pipeline auxiliary lines - Google Patents

Abstract

The invention relates to a method and a device for generating a pipeline auxiliary line, wherein the method comprises the following steps: performing space query on the pipeline data according to preset conditions, and determining the space coordinates of the pipeline according to a space reference coordinate system; creating a pipeline class and adding an element class index, calculating characteristic points of pipeline auxiliary lines according to the spatial coordinates of the pipeline and the element class index, generating first pipeline auxiliary lines, and adding pipeline marks to the corresponding first pipeline auxiliary lines. The beneficial effects of the invention include: screening pipeline data meeting preset conditions, acquiring space coordinates of pipelines in corresponding areas according to actual requirements, calculating characteristic points of pipeline auxiliary lines according to the space coordinates and the element class indexes, and generating first pipeline auxiliary lines, so that the calculation amount of generating the pipeline auxiliary lines in the topological structure is simplified, and the efficiency of generating the pipeline auxiliary lines is improved.

Description

A method and device for generating pipeline auxiliary lines

technical field

The invention relates to the technical field of pipeline data processing, in particular to a method and device for generating pipeline auxiliary lines.

Background technique

With the development of society and the continuous improvement of the current level of urbanization, the infrastructure construction is developing rapidly, and the underground pipe network system is getting bigger and bigger. In addition to the original water supply and drainage network, power grid, heating power network and communication lines, natural gas pipeline network The Internet, etc., the underground pipeline network is becoming more and more complex. Due to the rapid increase in infrastructure construction, the lack of effective management of the underground pipe network has resulted in redundant construction and waste of resources. During the construction, due to the lack of understanding of the underground pipe network, blindly started construction, resulting in gas leakage, digging and disconnection of water pipes, communication interruption and other damage to the underground pipe network occurred from time to time.

In the process of updating the old pipeline network and designing and planning the new pipeline network, it is necessary to process and design according to the corresponding pipeline conditions on the basis of a large amount of pipeline network data that has been formed, while the traditional manual drawing relies on artificial memory The management methods of manual statistics and analysis are inefficient, and it is difficult to adapt to the requirements of massive data in the rapid development of urbanization.

Contents of the invention

The technical problem to be solved by the present invention is to provide a method and device for generating pipeline auxiliary lines that overcome the above-mentioned problems or at least partially solve the above-mentioned problems.

The technical solution of the present invention to solve the above technical problems is as follows: On the one hand, the embodiment of the present invention discloses a method for generating pipeline auxiliary lines, including:

Acquiring the pipeline name of the pipeline data according to the first preset condition, the pipeline data including several sections of pipelines and pipeline marks;

performing a spatial query on the pipeline data according to a second preset condition, and determining the spatial coordinates of the pipeline according to a spatial reference coordinate system;

Create a pipeline class and add a feature class index according to the pipeline class, the pipeline class is created according to the type of the pipeline data and the information of the spatial coordinates;

calculating feature points of the pipeline auxiliary line according to the spatial coordinates of the pipeline and the feature class index;

A first pipeline auxiliary line is generated according to the feature points of the pipeline auxiliary line, and the pipeline mark is added to the corresponding first pipeline auxiliary line.

Optionally, the adding feature class index according to the pipeline class includes:

Add feature class database index, used to create pipeline point feature class database index and pipeline line feature class database index, and store database index information;

And/or, add a feature class spatial index, determine the starting point and grid value of the spatial index according to the geometric range of the pipeline feature layer, create a spatial index for the pipeline point feature class and the pipeline line feature class, and Calculate the grid range of pipeline elements, and store the grid code.

Optionally, each section of the pipeline includes a first end point and a second end point;

The calculating the feature points of the pipeline auxiliary line according to the spatial coordinates of the pipeline and the feature class index includes:

Calculate the first feature point of the pipeline auxiliary line according to the first end point and the feature class index, the first feature point is obtained by translating the first end point toward the normal direction of the pipeline , where the translation distance is the radius of the pipeline;

Calculate the second feature point of the pipeline auxiliary line according to the second end point and the feature class index, the second feature point is obtained by translating the second end point toward the normal direction of the pipeline, wherein , the translation distance is the radius of the pipeline.

Optionally, after obtaining the pipeline name of the pipeline data according to the first preset condition, the method further includes:

Finding a second pipeline auxiliary line corresponding to the pipeline data according to the pipeline name;

The second pipeline auxiliary line is deleted, and the layer of the pipeline data is initialized.

Optionally, the first preset condition includes at least one of the following:

the geographic location of the pipeline;

And/or, the material of the pipeline;

And/or, the size of the pipeline.

Optionally, the second preset condition includes at least one of the following:

the purpose of the pipeline;

And/or, the scope of use of the pipeline.

On the other hand, an embodiment of the present invention also provides a device for generating pipeline auxiliary lines, including:

The pipeline data acquisition module is used to acquire the pipeline name of the pipeline data according to the first preset condition, and the pipeline data includes several sections of pipelines and pipeline marks;

A pipeline coordinate acquisition module, configured to perform spatial query on the pipeline data according to the second preset condition, and determine the spatial coordinates of the pipeline according to the spatial reference coordinate system;

An index creation module, configured to create a pipeline class and add a feature class index according to the pipeline class, the pipeline class is created according to the type of the pipeline data and the information of the spatial coordinates;

A feature point calculation module, configured to calculate feature points of the pipeline auxiliary line according to the spatial coordinates of the pipeline and the feature class index;

The first auxiliary line generating module is configured to generate a first auxiliary line of pipeline according to the feature points of the auxiliary line of pipeline, and add the mark of the pipeline to the corresponding first auxiliary line of pipeline.

Optionally, the index creation module includes:

The first index creation sub-module is used to add a feature class database index, and is used to create a pipeline point feature class database index and a pipeline line feature class database index, and store database index information;

And/or, the second index creation submodule is used to add a feature class spatial index, and determine the starting point and grid value of the spatial index according to the geometric range of the pipeline feature layer, which are respectively the pipeline point feature class, the The pipeline line feature class creates a spatial index, calculates the grid range of the pipeline feature, and stores the grid code.

Optionally, each section of the pipeline in the device includes a first end point and a second end point;

The feature point calculation module includes:

The first feature point calculation submodule is used to calculate the first feature point of the pipeline auxiliary line according to the first end point and the feature class index, and the first feature point is obtained by moving the first end point toward The normal direction of the pipeline is obtained after translation, wherein the distance of translation is the radius of the pipeline;

The second feature point calculation submodule is used to calculate the second feature point of the pipeline auxiliary line according to the second end point and the feature class index, and the second feature point is obtained by moving the second end point toward the The normal direction of the pipeline is obtained after translation, where the translation distance is the radius of the pipeline.

Optionally, after obtaining the pipeline name of the pipeline data according to the first preset condition, the device further includes:

A search module, configured to search for a second pipeline auxiliary line corresponding to the pipeline data according to the pipeline name;

The initialization module is configured to delete the second pipeline auxiliary line, and initialize the layer of the pipeline data.

Optionally, the first preset condition includes at least one of the following:

the geographic location of the pipeline;

And/or, the material of the pipeline;

And/or, the size of the pipeline.

Optionally, the second preset condition includes at least one of the following:

the purpose of the pipeline;

And/or, the scope of use of the pipeline.

On the other hand, an embodiment of the present invention also provides an electronic device, the electronic device includes a processor, a memory, and a computer program stored in the memory and capable of running on the processor, the computer program being The processor executes the steps of realizing the method for generating pipeline auxiliary lines.

On the other hand, an embodiment of the present invention also provides a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the steps of the method for generating pipeline auxiliary lines are realized. .

The embodiment of the present invention has the following advantages: the present invention performs spatial query on the pipeline data according to the preset conditions, and determines the spatial coordinates of the pipeline according to the spatial reference coordinate system, and obtains the corresponding area according to actual needs by filtering the pipeline data satisfying the preset conditions The spatial coordinates of the inner pipeline, calculate the feature points of the pipeline auxiliary line according to the spatial coordinates and the feature class index, and generate the first pipeline auxiliary line, simplify the calculation amount of generating the pipeline auxiliary line in the topology structure, and improve the efficiency of generating the pipeline auxiliary line.

Description of drawings

FIG. 1 is a flow chart of steps for generating pipeline auxiliary lines provided by an embodiment of the present invention;

Fig. 2 is a structural block diagram of generating pipeline auxiliary lines provided by an embodiment of the present invention.

detailed description

The principles and features of the present invention are described below in conjunction with the accompanying drawings, and the examples given are only used to explain the present invention, and are not intended to limit the scope of the present invention.

As shown in Figure 1, Figure 1 is a flow chart of steps for generating pipeline auxiliary lines provided by an embodiment of the present invention, the method includes the following steps:

Step 101. Obtain the pipeline name of the pipeline data according to the first preset condition, and the pipeline data includes several sections of pipelines and pipeline marks;

In the process of updating the old pipe network or designing and planning the new pipe network, processing can be carried out on the basis of the formed pipe network data. Since the topological structure information in the existing pipe network data is complicated, the user can extract Part of the pipe network data, and preliminary processing of the part of the pipe network data.

In an optional embodiment, after obtaining the pipeline name of the pipeline data according to the first preset condition, the method further includes: searching for a second pipeline auxiliary line corresponding to the pipeline data according to the pipeline name, and deleting the second pipeline auxiliary line. Pipeline auxiliary lines, and initialize the layer of pipeline data.

Wherein, the first preset condition can include the geographic location of the pipeline, such as Jiangxia District, Wuhan City, Hubei Province; the first preset condition can also include the material of the pipeline, such as the pipeline is made of copper, plastic or cement; the first preset condition The size of the pipeline may be included, eg the diameter of the pipeline is 20cm.

Step 102. Perform spatial query on the pipeline data according to the second preset condition, and determine the spatial coordinates of the pipeline according to the spatial reference coordinate system;

Wherein, the second preset condition may include the use of the pipeline or the scope of use of the pipeline. Exemplarily, pipelines can be used in transportation facilities, including urban underground passages, urban subways, and tunnels; pipelines can be used in commercial facilities, such as underground shopping malls and underwater amusement parks; pipelines can be used in municipal public welfare pipeline facilities to improve urban road utilization and protect underground The facilities are running stably and provide reserved space for adding facilities in the future.

In an optional embodiment, the name (id) of the pipeline in a specific area or a specific attribute is found according to the second preset condition, and the corresponding auxiliary line is queried and deleted according to the pipeline id, and the layer of the pipeline data is initialized , to obtain a collection of pipeline data, let the collection be L1, traverse the collection L1, obtain a merged spatial range, expand the spatial range appropriately according to the actual needs, and obtain the collection L2, perform spatial query on the collection L2, and find out the need to generate auxiliary The id of the pipeline data of the line, and determine the spatial coordinates of the pipeline according to the spatial reference coordinate system. Let the extended spatial range be extent, set dSizeX=(extent.xmax-extent.xmin)/GridSizeX, dSizeY=(extent.ymax-extent.ymin)/GridSizeY, and obtain grid sizes dSizeX and dSizeY. Traversing vecConnectPnts, set the current ConnectPnt object pointer as p. Line and idx can be found from p, so that the line segment space object corresponding to line can be found, so that the coordinates (x, y) of the current p can be determined. Then the grid index (i, j) where p is located should be ((int)((x-extent.xmin)/dSizeX), (int)((y-extent.ymin)/dSizeY)), so that p can be determined The corresponding grid object vecvecConnectPnts[j*GridSizeX+i]. Call it vec ConnectPnts_ij. Just add p to vecConnectPnts_ij.

Step 103, create a pipeline class and add a feature class index according to the pipeline class, the pipeline class is created according to the type of the pipeline data and the information of the spatial coordinates;

Traverse the set L2, store the spatial data corresponding to the pipeline data L2, the pipeline id, the flag (flag) whether to participate in generation, and the pipeline flag in the arrays array_lines and array_ids, and array_flags and array_attrs respectively. Each element of array_attrs is an attribute array, which stores the attributes of the predicted fields, including the fields corresponding to the pipeline data, the pipe diameter size, the project number, and the pipeline type (if it is a drainage pipeline, it also includes the starting point elevation and the ending point elevation) Or you need to write to the fields of the pipeline auxiliary lines, respectively add feature class indexes according to the pipeline class array_lines, array_ids, array_flags and array_attrs, including:

Add feature class database index to speed up the query rate of pipeline point features Create a database index related to pipeline point feature class to speed up the query rate of pipeline line features Create a pipeline line feature class database index and store the database index information;

And/or, add feature class spatial index and store: determine the starting point and grid value of the spatial index according to the geometric range of the pipeline feature layer, create spatial indexes for the pipeline point feature class and pipeline line feature class respectively; calculate the pipeline feature grid range and store the grid code;

And/or, add feature class paging index and store: determine the paging index starting point and grid value according to the geometric range of the pipeline point feature layer and pipeline line feature layer, and create a paging index for the pipeline point feature class and pipeline line feature class ; Calculate the grid position of the pipeline elements, and store the grid code, grid geometry information, and grid attribute information.

Pipeline data is a class of vector data with a special topology. It includes pipeline points, pipeline lines, pipeline faces, pipeline auxiliary lines, and pipeline annotations. Among them, the pipeline line data is end-to-end line data, and the pipeline line data is a line segment with a starting point and a dead point, and the starting point and the dead point must be completely coincident with a certain pipeline point data. There will be no hanging and intersecting situations in the pipeline data, that is, the endpoint of the pipeline data must coincide with the endpoint of another pipeline data, or it exists independently and does not have relationship with other line segments. In this way, the pipeline data has a specific topology, that is, its endpoints are connected one by one. When generating auxiliary lines, there is no need to intersect the line segments to calculate the topological relationship, but to obtain it according to the coincidence relationship of points.

In this embodiment, each pipeline line segment includes a first end point and a second end point, and the process of calculating the feature points of the pipeline auxiliary line according to the spatial coordinates of the pipeline and the index of the feature class includes: according to the first end point and the feature class The index calculates the first feature point of the pipeline auxiliary line, and calculates the second feature point of the pipeline auxiliary line according to the second end point and the feature class index, where the first feature point and the second feature point are both by pointing the end point towards the normal of the pipeline It is obtained after the direction is translated, and the translation distance is the radius of the pipeline.

For the convenience of description, we take the first end point as the first point and the second end point as the end point.

Define a structure ConnectLine, which represents the topological connection of a line segment, which stores all the connection lines listfirstLine of the first point of the line segment (stored by a pointer array of ConnectLine type), all the connection lines listnextLine of the end point, and the id of the line segment , the spatial data of the line segment, the flag flag of whether the line segment participates in generation, the left feature point flp of the first point, the right feature point frp of the first point, the left feature point nlp of the tail point, the right feature point nrp, and the feature point connection line array extLine. Among them, the feature points flp, frp, nlp and nrp are the feature points obtained after the end point of each line segment is translated to the normal direction of the line segment, and the translation distance is the radius of the pipeline.

Define a structure ConnectPnt, which represents the topological connection of the first or last point of a line segment. It respectively stores the pointer line (the type is ConnectLine) of its corresponding topology line segment, and the index value idx (representing whether it is the first point or the end point, and the value is 0 or 1).

Define a pointer array vecConnectlines of ConnectLine type, and a pointer array vecConnectPnts of ConnectPnt type.

Loop through array_lines, set the current index as i. Create a new ConnectLine object cl, and assign array_ids[i], array_lines[i] and array_flags[i] to the corresponding items of cl respectively. Then add cl to the array vecConnectlines.

In the process of creating the pipeline class, traverse vecConnectlines, and set the current ConnectLine object pointer as cl. Create a new ConnectPnt object p0, assign cl to the line of p0, assign the idx of p0 to 0, then add p0 to vecConnectPnts; create a new ConnectPnt object p1, assign cl to the line of p1, and assign the idx of p1 to 1 , and then add p1 into vecConnectPnts.

In the process of establishing a spatial index, first define a grid G with the size of GridSizeX*GridSizeY through the predefined grid sizes GridSizeX and GridSizeY (generally determined according to the size of the data set or set to a fixed value). The grid type is an array of pointers of the ConnectPnt type, that is, an array of vector<ConnectPnts*> with the size of GridSizeX*GridSizeY is defined, which is vecvecConnectPnts.

After traversing vecConnectPnts, the ConnectPnt in vecConnectPnts is actually added to the grid index. However, in order to improve the efficiency of the algorithm and speed up the search for adjacent points, we can also make some modifications to the above process. Specifically, the storage in the grid is changed to vecvecConnectPntsSortedByX and vecvecConnectPntsSortedByY, and the object pointer of ConnectPnt is stored in the two arrays in the grid respectively. After the above process is completed, there will actually be two arrays of ConnectPnt pointers of the same size in each grid, and their stored contents are the same. As the name suggests, SortedByX and SortedByY are to sort ConnectPnt according to X and Y coordinates. The specific method is:

Traversing the grid G, assuming that the current index is i, then vecvecConnectPntsSortedByX[i] and vecvecConnectPntsSortedByY[i] are arrays storing ConnectPnt pointers respectively. Perform quick sorting on vecvecConnectPntsSortedByX[i]. Let the two ConnectPnt objects to be compared be p1 and p2 respectively, and the comparison condition is p1->line->line[p1->idx].x<p2->line->line [p2->idx].x. (The first line is ConnectLine, the second is its spatial object, and the connection index can access the point object). Perform quick sort on vecvecConnectPntsSortedByY[i], the comparison condition is p1->line->line[p1->idx].y<p2->line->line[p2->idx].y. After traversing the grid G in this way, the establishment of the grid index and the sorting of the connection points are completed.

In the process of creating a pipeline class, if the current pipeline type is a drainage line, before traversing vecConnectlines, it is necessary to generate the drainage direction auxiliary line process first. The process of generating the drainage direction auxiliary line is as follows:

Loop through array_lines, set the current index as i. From array_attrs[i], take out the starting point elevation and ending point elevation corresponding to the current line data, calculate the midpoint coordinates centerX and centerY of the current line segment, and calculate the length of the current line segment. Let dX be 0.5/length*(p1.x-p0.x), and dY be 0.5/length*(p1.y-p0.y) (p0, p1 are the starting point and ending point of the line segment respectively). If the elevation of the starting point is greater than the elevation of the ending point, the direction of water flow should be from the starting point to the ending point, and the end point coordinates of the other end of the auxiliary line arrow in the drainage direction otherX is centerX+dX, and otherY is centerY+dY; otherwise, otherX is centerX–dX, and otherY is centerY–dY. In this way, the two points of the arrow rod of the drainage direction auxiliary line are found.

Next, look for the two line segments of the arrow of the drainage direction auxiliary line. The coordinates of the tip of the arrow are otherX, otherY. In addition, you need to find the coordinates of the waist of the arrow on the left. First calculate the azimuth of the arrow rod, that is, the azimuth of the line connecting the center point and the other point. Let the azimuth from the left waist to the arrow be lazimuth, and the azimuth from the right waist to the arrow be razimuth, and the angle of the arrow to be expressed is 30 degrees (it can be any angle, set to 30 degrees for convenience), then lazimuth=azimuth–30/ 2; razimuth=azimuth+30/2. Let the length of the arrow be arrowlength, set arrowlength to be 1 (can be any desired length), then make lx=arrowlength*sin(lazimuth), ly=arrowlength*cos(lazimuth); rx=arrowlength*sin(razimuth), ry=arrowlength*cos(razimuth). Then point lp(otherX+lx, otherY+ly) is the coordinates of the left waist of the arrow, and point rp(otherX+rx, otherY+ry) is the coordinates of the right waist of the arrow. In this way, after the corresponding coordinates are formed into the auxiliary line segment, and the corresponding attribute value is added, the drainage direction auxiliary line is generated.

Step 104, calculating the feature points of the pipeline auxiliary line according to the spatial coordinates of the pipeline and the feature class index;

Among them, calculating the feature points of the pipeline auxiliary line includes the following sub-steps:

Step 104.1, traverse vecConnectlines, and set the current ConnectLine pointer as cl. Let p be cl->line[0], that is, p is the first end point of the line segment corresponding to cl, according to a certain tolerance size r (users can set it by themselves, or it can be set to a fixed value, such as 0.01), for all the lines around p ConnectPnt performs spatial query and stores it in the object listConnectPnts of type vector<ConnectPnt*>.

The specific method of the spatial query is:

Use the coordinates of the query point p(x,y) plus the tolerance size r to generate a query rectangle, and its xmin, ymin, xmax, and ymax are x-r, y-r, x+r, y+r respectively. Calculate the grid index values of the grid G where the coordinates of the four vertices of the query rectangle are located, and find all the grids covered by the grids where the four vertices are located (that is, the grid index values where the four vertices are located are respectively ( xmin_idx, ymin_idx), (xmax_idx, ymin_idx), (xmin_idx, ymax_idx), (xmax_idx, ymax_idx), then all the grids covered are all grids with row numbers from ymin_idx to ymax_idx and column numbers from xmin_idx to xmax_idx). And because in this application it is to find the endpoints connected together, the value of the tolerance r will be set very small, so there are four grids at most.

For each found mesh, look up its corresponding sorted array of vecConnectPntsSortedByX. For vecConnectPntsSortedByX, use the point value of (x-r, y-r) to find the lower bound index value, use the point value of (x+r, y+r) to find the upper bound index value, and the comparison condition is the comparison condition for the X value in the previous sorting method . After finding the index values of the upper and lower bounds, if the upper bound index value minus the lower bound index value is less than 10, that is, the number of elements meeting the interval condition is less than 10, then directly traverse all ConnectPnts from the lower bound index value to the upper bound index value, if If its y value is within the range of y-r to y+r, it meets the result requirements, and its ConnectPnt pointer is added to the result set setResult of each grid.

If the upper bound index value minus the lower bound index value is greater than or equal to 10, it is considered that there are many temporary results and there is a need for further query, then follow the same method, vecConnectPntsSortedByY, use the point value of (x-r, y-r) to find the lower bound index value, Use the point value of (x+r, y+r) to find the upper bound index value, and the comparison condition is the comparison condition for the Y value in the previous sorting method. At this time, a collection setResultX can be generated for the values of the upper bound and lower bound of the result of vecConnectPntsSortedByX, and a collection setResultY can be generated for vecConnectPntsSortedByY. At this time, setResultY is traversed, and if its elements exist in setResultX, the result is added to setResult, and finally the result set setResult of a single grid is obtained.

For each grid found setResult, union its results. The specific method is: create an empty setResultAll, traverse the setResult elements of each grid, if the current element does not exist in the setResultAll, add the current element to the setResultAll, and finally get the union of all the results.

In this way, the above-mentioned spatial query operation is completed.

Step 104.2, define an array listFoundConnectPnts. It is an array of ConnectPnt type pointers. Traverse the array listConnectPnts, for the current ConnectPnt object cp, if cp->line==cl, then continue; (encounter itself), otherwise find the point space object p1 corresponding to cp(cp->line->line[cp- >idx]). If the distance between p and p1 is less than r, add the current cp to listFoundConnectPnts. This step is to ensure that the queried ConnectPnt is within the tolerance range.

Next, traverse listFoundConnectPnts. For the current ConnectPnt object cp, if the listfirstLine of cl does not contain cp->line, add cp->line to the listfirstLine of cl. If cp->idx is 0, if the listfirstLine of cp->line does not contain cl, add cl to the listfirstLine of cp->line. Otherwise, if cp->idx is 1, it is judged that if the listnextLine of cp->line does not contain cl, then cl is added to the listnextLine of cp->line.

Similarly, let p be cl->line[1], that is, p is the end point of the line segment corresponding to cl, according to a certain tolerance size r, perform spatial query on all ConnectPnt around p, and store them in the vector<ConnectPnt*> type The object listConnectPnts. Then filter by distance to get listFoundConnectPnts. Traverse listFoundConnectPnts. For the current ConnectPnt object cp, if the listnextLine of cl does not contain cp->line, add cp->line to the listnextLine of cl. If cp->idx is 0, if the listfirstLine of cp->line does not contain cl, add cl to the listfirstLine of cp->line. Otherwise, if cp->idx is 1, it is judged that if the listnextLine of cp->line does not contain cl, then cl is added to the listnextLine of cp->line.

So far, the index building work of the pipeline connecting the first and last endpoints of each pipeline is completed, that is, for each pipeline, the pipeline connected to it can be found through its listfirstLine and listnextLine.

Step 104.3. After establishing the index of the pipeline connecting the first and last endpoints of the pipeline, calculate the feature points of the auxiliary line according to the spatial coordinates where the first and last endpoints are located, specifically including the following sub-steps:

Step 104.3.1. Let r be the radius of the pipeline, first determine the index of the left connecting line.

Specifically, FindLeft is to find the first connection line index on the left of the azimuth in the azimuths. Let max be -10000, actmax be -10000, maxidx be -1, actmaxidx be -1. Traverse azimuths, set the current index as i, if azimuths[i] is smaller than azimuth, and azimuths[i] is greater than actmax, then actmax is assigned the value azimuths[i], and actmaxidx is assigned the value i. If azimuths[i] is greater than max, then max is assigned to azimuths[i] and maxidx is assigned to i. After traversing, if actmaxidx is greater than or equal to 0, return actmaxidx; otherwise, return maxidx.

Step 104.3.2. Determine the index of the connecting line on the right.

FindRight, that is to find the azimuth azimuth in the azimuths on the first connecting line index on the right. Let min be 10000, actmin be 10000, minidx be -1, actminidx be -1. Traverse azimuths, set the current index as i, if azimuths[i] is greater than azimuth, and azimuths[i] is less than actmin, then assign actmin to azimuths[i] and actminidx to i. If azimuths[i] is less than min, then min is assigned to azimuths[i] and minidx is assigned to i. After traversing, if actminidx is greater than or equal to 0, return actminidx; otherwise, return minidx.

Step 104.3.3,

Calculate the coordinate increment calcDeltaXY function, set its parameter list as X0, Y0, X1, Y1, r, deltaX, deltaY. Let dy=Y1-Y0, dx=X1-X0. The initial value of dy1 is 0, and the initial value of dx1 is 0.

If dx is equal to 0, then dx1 is -r and dy1 is 0 if dy is greater than 0. Otherwise, dx1 is r and dy1 is 0.

Otherwise, let k=dy/dx. Let val=r*sqrt(k*k/(1+k*k)); valy=r*sqrt(1/(1+k*k)). If dy is greater than 0, dx1 is -val; otherwise dx1 is val. If dx is greater than 0, dy1 is valy; otherwise dy1 is -valy.

deltaX is dx1, deltaY is dy1.

So far the calcDeltaXY function ends.

Step 104.3.4,

The parameter list of the K function is (x0, y0, x1, y1). Returns (y1-y0)/(x1-x0).

Step 104.3.5,

The parameter list of the b function is (x0, y0, x1, y1). Returns (x1*y0-x0*y1)/(x1-x0).

Step 104.3.6,

calcCrossXY, that is, the intersection point of the pipeline corresponding to the calculation pipeline cl and lindex or the intersection point of its extension line, the parameter list is set to x0, y0, x1, y1, x2, y2, r1, r2, bValidL, xL, yL. bValidL, xL, yL are output parameters. The algorithm is as follows:

Define deltaXf and deltaYf, representing the x, y coordinate increment of the left side of the first line ((x0, y0), (x1, y1)) away from the normal along the r1 distance; deltaXn, deltaYn represent the second line (( x1, y1), (x2, y2)) The left side of (x2, y2)) is offset from the normal along the x, y coordinate increment of the distance r2. The calculation method is to call the calcDeltaXY method: pass in the parameters x0, y0, x1, y1, r1, deltaXf, deltaYf to get deltaXf, deltaYf; pass in the parameters x1, y1, x2, y2, r2, deltaXn, deltaYn to get deltaXn, deltaYn.

Let dxf=x1-x0, dxn=x2-x1, dyf=y1-y0, dyn=y2-y1.

If dxf is equal to 0 and dxn is equal to 0, that is, both lines are vertical and on the same straight line, then xL is x1+detalXf, and yL is y1. If r1 and r2 are not equal, bValidL is false and the program returns.

If dxf is equal to 0 but dxn is not equal to 0, let kn=K(x1, y1, x2, y2), bn=b(x1+deltaXn, y1+deltaYn, x2+deltaXn, y2+deltaYn). Among them, K is the slope function, and b is the intercept function, corresponding to K and b in the straight line expression y=Kx+b. Then xL is x1+deltaXf, and yL is kn*xL+bn.

If dxf is not equal to 0 but dxn is equal to 0, let kf=K(x0,y0,x1,y1), bf=b(x0+deltaXf, y0+deltaYf, x1+deltaXf, y1+deltaYf). Then xL is x1+deltaXn, and yL is kf*xL+bf.

If dxf is not equal to 0 and dxn is not equal to 0, let kn=K(x1,y1,x2,y2), bn=b(x1+deltaXn,y1+deltaYn,x2+deltaXn,y2++deltaYn), kf=K (x0, y0, x1, y1), bf = b(x0+deltaXf, y0+deltaYf, x1+deltaXf, y1+deltaYf). If kf is equal to kn: if r1 is equal to r2, then xL is x1+deltaXf, yL is y1+deltaYf, bValidL is true, and the program returns; otherwise, bValidL is false, and the program returns. If kf is not equal to kn, xL is (bn-bf)/(kf-kn), and yL is (kf*bn-kn*bf)/(kf-kn).

Finally, let dLf=yL-(y0+deltaYf), dLn=yL-(y2+deltaYn). If dLf*dyf<0 or dLn*dyn>0, then bValidL is false, otherwise bValidL is true, and the program returns. This step is to judge the position relationship between the final intersection point and the line segment ((x0,y0),(x1,y1)) and ((x1,y1),(x2,y2)). An intersection is considered invalid if it is outside the normal radius of the line segment.

So far the calcCrossXY function ends.

Step 104.3.7, calculating the feature points of the auxiliary line;

Calculate the feature points on the left side of the auxiliary line: if cl->flp==NULL or cl->frp==NULL, then perform the following steps: Let (x1,y1) be cl->line[0], which is the pipeline corresponding to cl The first endpoint of , (x2, y2) is the tail endpoint of the pipeline corresponding to cl. If the length of cl->listfirstLine is not 0, define a lindex and rindex, which respectively represent the index of the connecting pipeline referenced on the left and the index of the connecting pipeline referenced on the right. If the length of cl->listfirstLine is 1, then there is only one connecting pipeline at this time, and the values of lindex and rindex are 0. Otherwise, calculate the azimuth azimuth of the ray from the first point to the end point of the current connection line cl. And traverse cl->listfirstLine to calculate the azimuth of each corresponding connecting line. At this time, pay attention to the direction of the calculated azimuth. The azimuth direction should be calculated from the point corresponding to (x1,y1). Therefore, let the currently traversed ConnectLine be line. If line->listfirstLine contains cl, it means that the first point of line is corresponding to (x1, y1), and its azimuth is calculated from line[0] to line[1] of line; if If it is not included, it means (x1, y1) corresponding to the end point, and its azimuth is calculated from line[1] to line[0] of the line. After the azimuth is calculated, it is stored in the array azimuths. Then use the FindLeft method to find the corresponding lindex, and use the FindRight method to find the corresponding rindex. Unless otherwise specified below, the pipeline corresponding to lindex refers to the line cl->listfirstLine[lindex]; the pipeline corresponding to rindex refers to the line cl->listfirstLine[rindex].

The definition point (x3l, y3l) represents the endpoint of the pipeline corresponding to lindex that is not connected to (x1, y1). The definition point (x3r, y3r) represents the endpoint of the pipeline corresponding to rindex that is not connected to (x1, y1). Define (rx3, ry3), which represents the auxiliary line feature point of the connecting pipeline to be obtained. Let rl be the radius of the pipeline corresponding to lindex. rr is the radius of the pipeline corresponding to rindex.

If cl->flp is NULL, the left feature point needs to be calculated. The calculation method is: if the listfirstLine of the pipeline corresponding to lindex contains cl, that is, its first endpoint corresponds to (x1, y1), then (x3l, y3l) is the tail endpoint of the pipeline corresponding to lindex; otherwise (x3l, y3l) is lindex The first endpoint of the corresponding pipeline. Call the function calcCrossXY, the incoming parameters are x3l, y3l, x1, y1, x2, y2, rl, r, and the outgoing parameters are bValidL, lx, ly. Among them, bValidL represents whether the calculated intersection coordinates are valid; (lx, ly) represents the calculated intersection coordinates.

Going back to the previous step, if bValidL is false, the calculation of the intersection point lx, ly fails. At this time, the normal offset points of the two line segments should be taken respectively, and a line should be connected between the two offset points. The specific method is: define deltaX, deltaY, use calcDeltaXY, pass in (x1, y1, x2, y2, r, deltaX, deltaY), and find deltaX, deltaY. Then lx=x1+deltaX, ly=y1+deltaY. The flp of cl is (lx, ly). Let this point be A.

Define deltaX3, deltaY3, use calcDeltaXY, pass in (x1, y1, x3l, y3l, rl, deltaX3, deltaY3), and calculate deltaX3, deltaY3. Then rx3=x1-deltaX3, ry3=y1-deltaY3.

If the listfirstLine of the pipeline corresponding to lindex contains cl, that is, the head end of the pipeline corresponding to lindex corresponds to (x1, y1), then the frp of the pipeline corresponding to lindex is (rx3, ry3), otherwise the nlp of the pipeline corresponding to lindex is (rx3, ry3). Let this point be B. Finally, a line segment AB is generated and added to the extLine of cl.

If bValidL is true, the intersection point lx,ly is calculated successfully. Then the flp of cl is (lx, ly). If the listfirstLine of the pipeline corresponding to lindex contains cl, that is, the head end of the pipeline corresponding to lindex corresponds to (x1, y1), then the frp of the pipeline corresponding to lindex is the flp of cl. Otherwise, the nlp of the pipeline corresponding to lindex is the flp of cl.

So far, the calculation of the feature points on the left is completed, and the feature points on the left side of the auxiliary line are calculated below.

If the length of listfirstLine of cl is 1, that is, lindex and rindex are equal to the same line, then rx=x1*2-lx, ry=y1*2-ly can be obtained by using the symmetry feature. The frp of cl is (rx, ry). Let it be point A. If bValidL is false, let lx3=x1*2-rx3, ly3=y1*2-ry3. If the listfirstLine of the pipeline corresponding to rindex contains cl, that is, the head end of the pipeline corresponding to rindex corresponds to (x1, y1), then the flp of the pipeline corresponding to rindex is (lx3, ly3). Otherwise, the nrp of the pipeline corresponding to rindex is (lx3, ly3). Let it be point B. Finally, a line segment AB is generated and added to the extLine of cl. If bValidL is true, if the listfirstLine of the pipeline corresponding to rindex contains cl, then the flp of the pipeline corresponding to rindex is the frp of cl; otherwise, the nrp of the pipeline corresponding to rindex is the frp of cl.

If the length of listfirstLine of cl is not 1, it is similar to finding the feature points on the left. The calculation method is:

If the listfirstLine of the pipeline corresponding to rindex contains cl, that is, its first endpoint corresponds to (x1, y1), then (x3r, y3r) is the tail endpoint of the pipeline corresponding to rindex; otherwise (x3r, y3r) is the first endpoint of the pipeline corresponding to rindex endpoint. Call the function calcCrossXY, the incoming parameters are x2, y2, x1, y1, x3r, y3r, r, rr, and the outgoing parameters are bValidR, rx, ry. Among them, bValidR represents whether the calculated intersection coordinates are valid; (rx, ry) represents the calculated intersection coordinates.

If bValidR is false, that is, the calculation of intersection points rx, ry fails. At this time, the normal offset points of the two line segments should be taken respectively, and a line should be connected between the two offset points. The specific method is: define deltaX, deltaY, use calcDeltaXY, pass in (x1, y1, x2, y2, r, deltaX, deltaY), and find deltaX, deltaY. Then rx=x1-deltaX, ry=y1-deltaY. The frp of cl is (rx, ry). Let this point be A.

Define deltaX3, deltaY3, use calcDeltaXY, pass in (x1, y1, x3r, y3r, rr, deltaX3, deltaY3), and calculate deltaX3, deltaY3. Then rx3=x1+deltaX3, ry3=y1+deltaY3.

If the listfirstLine of the pipeline corresponding to rindex contains cl, that is, the head end of the pipeline corresponding to rindex corresponds to (x1, y1), then the flp of the pipeline corresponding to rindex is (rx3, ry3), otherwise the nrp of the pipeline corresponding to rindex is (rx3, ry3). Let this point be B. Finally, a line segment AB is generated and added to the extLine of cl.

If bValidR is true, the intersection point rx, ry is calculated successfully. Then the frp of cl is (rx, ry). If the listfirstLine of the pipeline corresponding to rindex contains cl, that is, the head end of the pipeline corresponding to rindex corresponds to (x1, y1), then the flp of the pipeline corresponding to rindex is the frp of cl. Otherwise, the nrp of the pipeline corresponding to rindex is the frp of cl.

So far, the case where the length of listfirstLine of cl is not zero is discussed.

Next, we discuss the case where the length of listfirstLine of cl is zero. At this point, since there are no connecting lines, the method of generating auxiliary lines is relatively simple, that is, calculating the normal offset points on both sides of the first end point. However, at the end of the pipeline, it needs to be extended a little to close the auxiliary line. It is advisable to set the length to be extended as R. First, define deltaX, deltaY. Through calcDeltaXY, the parameters are x1, y1, x2, y2, r, deltaX, deltaY to calculate deltaX, deltaY. Let lx=x1+deltaX, ly=y1+deltaY, rx=x1-deltaX, ry=y1-deltaY. Then the flp of cl is (lx, ly), and the frp is (rx, ry). Define lxe, lye, rxe, rye. Call GetPntOnParalline with parameters x1, y1, x2, y2, lx, ly, -R, lxe, lye to get lxe, lye. Call GetPntOnParalline with parameters x1, y1, x2, y2, rx, ry, -R, rxe, rye to get rxe, rye. Connect the frp of cl, (rxe, rye), (lxe, lye), and the flp of cl to form a line segment in turn, and add them to the extLine of cl.

Step 104.3.8,

The implementation of the GetPntOnParalline function is as follows:

Parameter list: x1,y1,x2,y2,xp,yp,length,x,y. x, y are outgoing parameters.

The shilling len1 is equal to the length of the line segment ((x1, y1), (x2, y2)), dx=x2-x1, dy=y2-y1.

Let rate=length/len1. Then x=xp+dx*rate, y=yp+dy*rate. Get the desired parallel line point.

The above is to complete the calculation that the flp of cl is empty or the frp is empty.

Step 104.3.9, complete the calculation that nlp of cl is empty or nrp is empty.

Let (x1, y1) be cl->line[1], that is, the end point of the pipeline corresponding to cl, and (x2, y2) be the first end point of the pipeline corresponding to cl. If the length of cl->listnextLine is not 0, define a lindex and rindex, which respectively represent the index of the connecting pipeline referenced on the left and the index of the connecting pipeline referenced on the right.

If the length of cl->listnextLine is 1, then there is only one connecting pipeline at this time, and the values of lindex and rindex are 0. Otherwise, calculate the azimuth azimuth of the ray from the end point to the first point of the current connection line cl. And traverse cl->listnextLine to calculate the azimuth of each corresponding connecting line. At this time, pay attention to the direction of the calculated azimuth. The azimuth direction should be calculated from the point corresponding to (x1,y1). Therefore, let the currently traversed ConnectLine be line. If line->listfirstLine contains cl, it means that the first point of line is corresponding to (x1, y1), and its azimuth is calculated from line[0] to line[1] of line; if If it is not included, it means (x1, y1) corresponding to the end point, and its azimuth is calculated from line[1] to line[0] of the line. After the azimuth is calculated, it is stored in the array azimuths. Then use the FindLeft method to find the corresponding lindex, and use the FindRight method to find the corresponding rindex. Unless otherwise specified below, the pipeline corresponding to lindex refers to the line cl->listnextLine[lindex]; the pipeline corresponding to rindex refers to the line cl->listnextLine[rindex].

The definition point (x3l, y3l) represents the endpoint of the pipeline corresponding to lindex that is not connected to (x1, y1). The definition point (x3r, y3r) represents the endpoint of the pipeline corresponding to rindex that is not connected to (x1, y1). Define (rx3, ry3), which represents the auxiliary line feature point of the connecting pipeline to be obtained. Let rl be the radius of the pipeline corresponding to lindex. rr is the radius of the pipeline corresponding to rindex.

If cl->nrp is NULL, the feature points on the right need to be calculated. The calculation method is: if the listfirstLine of the pipeline corresponding to lindex contains cl, that is, its first endpoint corresponds to (x1, y1), then (x3l, y3l) is the tail endpoint of the pipeline corresponding to lindex; otherwise (x3l, y3l) is lindex The first endpoint of the corresponding pipeline. Call the function calcCrossXY, the incoming parameters are x3l, y3l, x1, y1, x2, y2, rl, r, and the outgoing parameters are bValidR, rx, ry. Among them, bValidR represents whether the calculated intersection coordinates are valid; (rx, ry) represents the calculated intersection coordinates.

If bValidR is false, that is, the calculation of intersection points rx, ry fails. At this time, the normal offset points of the two line segments should be taken respectively, and a line should be connected between the two offset points. The specific method is: define deltaX, deltaY, use calcDeltaXY, pass in (x1, y1, x2, y2, r, deltaX, deltaY), and find deltaX, deltaY. Then rx=x1+deltaX, ry=y1+deltaY. The nrp of cl is (rx, ry). Let this point be A.

Define deltaX3, deltaY3, use calcDeltaXY, pass in (x1, y1, x3l, y3l, rl, deltaX3, deltaY3), and calculate deltaX3, deltaY3. Then rx3=x1-deltaX3, ry3=y1-deltaY3.

If the listfirstLine of the pipeline corresponding to lindex contains cl, that is, the head end of the pipeline corresponding to lindex corresponds to (x1, y1), then the frp of the pipeline corresponding to lindex is (rx3, ry3), otherwise the nlp of the pipeline corresponding to lindex is (rx3, ry3). Let this point be B. Finally, a line segment AB is generated and added to the extLine of cl.

If bValidR is true, the intersection point rx, ry is calculated successfully. Then the nrp of cl is (rx, ry). If the listfirstLine of the pipeline corresponding to lindex contains cl, that is, the head end of the pipeline corresponding to lindex corresponds to (x1, y1), then the frp of the pipeline corresponding to lindex is the nrp of cl. Otherwise, the nlp of the pipeline corresponding to lindex is the nrp of cl.

So far, the feature points on the right are calculated, and then the feature points on the left are calculated.

If the length of listnextLine of cl is 1, that is, lindex and rindex are equal to the same line, then the symmetry feature can be used to obtain lx=x1*2-rx, ly=y1*2-ry. The nlp of cl is (lx, ly). Let it be point A. If bValidR is false, let lx3=x1*2-rx3, ly3=y1*2-ry3. If the listfirstLine of the pipeline corresponding to rindex contains cl, that is, the head end of the pipeline corresponding to rindex corresponds to (x1, y1), then the flp of the pipeline corresponding to rindex is (lx3, ly3). Otherwise, the nrp of the pipeline corresponding to rindex is (lx3, ly3). Let it be point B. Finally, a line segment AB is generated and added to the extLine of cl. If bValidR is true, if the listfirstLine of the pipeline corresponding to rindex contains cl, then the flp of the pipeline corresponding to rindex is the nlp of cl; otherwise, the nrp of the pipeline corresponding to rindex is the nlp of cl.

If the length of listnextLine of cl is not 1, it is similar to finding the feature points on the right. The calculation method is:

If the listfirstLine of the pipeline corresponding to rindex contains cl, that is, its first endpoint corresponds to (x1, y1), then (x3r, y3r) is the tail endpoint of the pipeline corresponding to rindex; otherwise (x3r, y3r) is the first endpoint of the pipeline corresponding to rindex endpoint. Call the function calcCrossXY, the incoming parameters are x2, y2, x1, y1, x3r, y3r, r, rr, and the outgoing parameters are bValidL, lx, ly. Among them, bValidL represents whether the calculated intersection coordinates are valid; (lx, ly) represents the calculated intersection coordinates.

If bValidL is false, that is, the calculation of the intersection point lx, ly fails. At this time, the normal offset points of the two line segments should be taken respectively, and a line should be connected between the two offset points. The specific method is: define deltaX, deltaY, use calcDeltaXY, pass in (x1, y1, x2, y2, r, deltaX, deltaY), and find deltaX, deltaY. Then lx=x1-deltaX, ly=y1-deltaY. The nlp of cl is (lx, ly). Let this point be A.

Define deltaX3, deltaY3, use calcDeltaXY, pass in (x1, y1, x3r, y3r, rr, deltaX3, deltaY3), and calculate deltaX3, deltaY3. Then rx3=x1+deltaX3, ry3=y1+deltaY3.

If the listfirstLine of the pipeline corresponding to rindex contains cl, that is, the head end of the pipeline corresponding to rindex corresponds to (x1, y1), then the flp of the pipeline corresponding to rindex is (rx3, ry3), otherwise the nrp of the pipeline corresponding to rindex is (rx3, ry3). Let this point be B. Finally, a line segment AB is generated and added to the extLine of cl.

If bValidL is true, the intersection point lx,ly is calculated successfully. Then the nlp of cl is (lx, ly). If the listfirstLine of the pipeline corresponding to rindex contains cl, that is, the head end of the pipeline corresponding to rindex corresponds to (x1, y1), then the flp of the pipeline corresponding to rindex is the nlp of cl. Otherwise, the nrp of the pipeline corresponding to rindex is the nlp of cl.

So far, the case where the length of the listnextLine of cl is not zero has been discussed.

Next, we discuss the case where the length of listnextLine of cl is zero. At this point, since there are no connecting lines, the method of generating auxiliary lines is relatively simple, that is, calculating the normal offset points on both sides of the first end point. However, at the end of the pipeline, it needs to be extended a little to close the auxiliary line. It is advisable to set the length to be extended as R. First, define deltaX, deltaY. Through calcDeltaXY, the parameters are x1, y1, x2, y2, r, deltaX, deltaY to calculate deltaX, deltaY. Let lx=x1-deltaX, ly=y1-deltaY, rx=x1+deltaX, ry=y1+deltaY. Then the nlp of cl is (lx, ly), and the nrp is (rx, ry). Define lxe, lye, rxe, rye. Call GetPntOnParalline with parameters x1, y1, x2, y2, lx, ly, -R, lxe, lye to get lxe, lye. Call GetPntOnParalline with parameters x1, y1, x2, y2, rx, ry, -R, rxe, rye to get rxe, rye. Connect the nrp of cl, (rxe, rye), (lxe, lye), and the nlp of cl into line segments in turn, and add them to the extLine of cl.

Step 105: Generate a first pipeline auxiliary line according to the feature points of the pipeline auxiliary line, and add the pipeline mark to the corresponding first pipeline auxiliary line.

The first feature point and the second feature point generated in step 104 are connected. Specifically, traverse vecConnectlines, and for each connection line object cl, connect its flp and nlp to obtain the left auxiliary line; connect its frp and nrp to obtain the right auxiliary line. Traverse the extLine of cl to generate each additional connecting line segment. For each generated auxiliary line, add a pipeline mark, and use the attribute value in the previously recorded array_attrs to assign corresponding attributes to it. So far, the algorithm for generating all pipeline auxiliary lines has been executed.

In the embodiment of the present invention, by screening the pipeline data satisfying the preset conditions, obtaining the spatial coordinates of the pipelines in the corresponding area according to the actual needs, calculating the feature points of the pipeline auxiliary lines according to the spatial coordinates and the feature class index, and generating the first pipeline auxiliary line, it can be Simplify the calculation amount of generating pipeline auxiliary lines in the topology structure, and improve the efficiency of generating pipeline auxiliary lines.

It should be noted that, for the method embodiment, for the sake of simple description, it is expressed as a series of action combinations, but those skilled in the art should know that the embodiment of the present invention is not limited by the described action sequence, because According to the embodiment of the present invention, certain steps may be performed in other orders or simultaneously. Secondly, those skilled in the art should also know that the embodiments described in the specification belong to preferred embodiments, and the actions involved are not necessarily required by the embodiments of the present invention.

In order to implement the above method, an embodiment of the present invention also provides a device for generating auxiliary pipeline lines. FIG. 2 is a structural block diagram of a device for generating auxiliary pipeline lines provided by an embodiment of the present invention. The device includes:

The pipeline data acquisition module 201 is configured to acquire the pipeline name of the pipeline data according to the first preset condition, and the pipeline data includes several sections of pipelines and pipeline marks;

The pipeline coordinate acquisition module 202 is configured to perform spatial query on the pipeline data according to the second preset condition, and determine the spatial coordinates of the pipeline according to the spatial reference coordinate system;

An index creation module 203, configured to create a pipeline class and add a feature class index according to the pipeline class, the pipeline class is created according to the type of the pipeline data and the information of the spatial coordinates;

A feature point calculation module 204, configured to calculate feature points of the pipeline auxiliary line according to the spatial coordinates of the pipeline and the feature class index;

The first auxiliary line generating module 205 is configured to generate a first auxiliary line of the pipeline according to the feature points of the auxiliary line of the pipeline, and add the mark of the pipeline to the corresponding first auxiliary line of the pipeline.

In an optional embodiment, the index creation module 203 may include:

The first index creation sub-module is used to add a feature class database index, and is used to create a pipeline point feature class database index and a pipeline line feature class database index, and store database index information;

And/or, the second index creation submodule is used to add a feature class spatial index, and determine the starting point and grid value of the spatial index according to the geometric range of the pipeline feature layer, which are respectively the pipeline point feature class, the The pipeline line feature class creates a spatial index, calculates the grid range of the pipeline feature, and stores the grid code.

In an optional embodiment, each section of the pipeline in the device includes a first end point and a second end point; the feature point calculation module 204 may include:

The first feature point calculation submodule is used to calculate the first feature point of the pipeline auxiliary line according to the first end point and the feature class index, and the first feature point is obtained by moving the first end point toward The normal direction of the pipeline is obtained after translation, wherein the distance of translation is the radius of the pipeline;

The second feature point calculation submodule is used to calculate the second feature point of the pipeline auxiliary line according to the second end point and the feature class index, and the second feature point is obtained by moving the second end point toward the The normal direction of the pipeline is obtained after translation, where the translation distance is the radius of the pipeline.

In an optional embodiment, after obtaining the pipeline name of the pipeline data according to the first preset condition, the device further includes:

A search module, configured to search for a second pipeline auxiliary line corresponding to the pipeline data according to the pipeline name;

The initialization module is configured to delete the second pipeline auxiliary line, and initialize the layer of the pipeline data.

In an optional embodiment, the first preset condition includes at least one of the following:

the geographic location of the pipeline;

And/or, the material of the pipeline;

And/or, the size of the pipeline.

In an optional embodiment, the second preset condition includes at least one of the following:

the purpose of the pipeline;

And/or, the scope of use of the pipeline.

The embodiment of the present invention has the following advantages: the embodiment of the present invention filters the pipeline data satisfying the preset conditions, and obtains the spatial coordinates of the pipeline in the corresponding area according to actual needs, calculates the feature points of the pipeline auxiliary line according to the spatial coordinates and the feature class index, and Generating the first pipeline auxiliary line can simplify the calculation amount of generating the pipeline auxiliary line in the topology structure and improve the efficiency of generating the pipeline auxiliary line.

An embodiment of the present invention also provides an electronic device, including a processor, a memory, and a computer program stored on the memory and capable of running on the processor. When the computer program is executed by the processor, the above-mentioned generation pipeline assistance is realized. Each process of the line method embodiment can achieve the same technical effect, so in order to avoid repetition, it will not be repeated here.

The embodiment of the present invention also provides a computer-readable storage medium, on which a computer program is stored. When the computer program is executed by a processor, each process in the above-mentioned embodiment of the method for generating pipeline auxiliary lines can be achieved, and the same Technical effects, in order to avoid repetition, will not be repeated here.

Each embodiment in this specification is described in a progressive manner, each embodiment focuses on the difference from other embodiments, and the same and similar parts of each embodiment can be referred to each other.

Those skilled in the art should understand that the embodiments of the present invention may be provided as methods, apparatuses, or computer program products. Accordingly, embodiments of the invention may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, embodiments of the invention may take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

Embodiments of the present invention are described with reference to flowcharts and/or block diagrams of methods, terminal devices (systems), and computer program products according to embodiments of the present invention. It should be understood that each procedure and/or block in the flowchart and/or block diagram, and a combination of procedures and/or blocks in the flowchart and/or block diagram can be realized by computer program instructions. These computer program instructions may be provided to a general purpose computer, special purpose computer, embedded processor or processor of other programmable data processing terminal equipment to produce a machine such that instructions executed by the computer or processor of other programmable data processing terminal equipment Produce means for realizing the functions specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing terminal to operate in a specific manner, such that the instructions stored in the computer-readable memory produce an article of manufacture comprising instruction means, the The instruction means implements the functions specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions can also be loaded into a computer or other programmable data processing terminal equipment, so that a series of operational steps are performed on the computer or other programmable terminal equipment to produce computer-implemented processing, thereby The instructions executed above provide steps for implementing the functions specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

Having described preferred embodiments of embodiments of the present invention, additional changes and modifications to these embodiments can be made by those skilled in the art once the basic inventive concept is appreciated. Therefore, the appended claims are intended to be construed to cover the preferred embodiment and all changes and modifications which fall within the scope of the embodiments of the present invention.

Finally, it should also be noted that in this text, relational terms such as first and second etc. are only used to distinguish one entity or operation from another, and do not necessarily require or imply that these entities or operations, any such actual relationship or order exists. Furthermore, the term "comprises", "comprises" or any other variation thereof is intended to cover a non-exclusive inclusion such that a process, method, article, or terminal equipment comprising a set of elements includes not only those elements, but also includes elements not expressly listed. other elements identified, or also include elements inherent in such a process, method, article, or end-equipment. Without further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of additional identical elements in the process, method, article or terminal device comprising said element.

The above descriptions are only preferred embodiments of the present invention, and are not intended to limit the present invention. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present invention shall be included in the protection of the present invention. within range.

Claims (8)

1. A method of generating a pipeline assist line, comprising:

acquiring a pipeline name of pipeline data according to a first preset condition, wherein the pipeline data comprises a plurality of sections of pipelines and pipeline marks;

according to a second preset condition, carrying out spatial query on the pipeline data, and determining the spatial coordinates of the pipeline according to a spatial reference coordinate system;

creating a pipeline class and adding an element class index according to the pipeline class, wherein the pipeline class is created according to the type of the pipeline data and the information of the spatial coordinates;

calculating the characteristic points of the pipeline auxiliary line according to the spatial coordinates of the pipeline and the element class indexes;

generating a first pipeline auxiliary line according to the characteristic points of the pipeline auxiliary line, and adding the pipeline mark to the corresponding first pipeline auxiliary line;

wherein each section of the pipeline comprises a first endpoint and a second endpoint;

the calculating the characteristic point of the pipeline auxiliary line according to the spatial coordinate of the pipeline and the element class index comprises the following steps:

calculating a first feature point of the pipeline auxiliary line according to the first endpoint and the element class index, wherein the first feature point is obtained by translating the first endpoint towards the normal direction of the pipeline, and the translation distance is the radius of the pipeline;

calculating a second feature point of the pipeline auxiliary line according to the second endpoint and the element class index, wherein the second feature point is obtained by translating the second endpoint towards the normal direction of the pipeline, and the translation distance is the radius of the pipeline;

the generating of the first auxiliary pipeline line according to the feature points of the auxiliary pipeline line specifically includes: and connecting the generated first characteristic point and the second characteristic point.

2. The method of claim 1, wherein adding the element class index according to the pipeline class comprises:

adding element class database indexes, creating pipeline point element class database indexes and pipeline line element class database indexes, and storing database index information;

and/or adding element class spatial indexes, determining a spatial index starting point and a grid value according to the geometric range of the pipeline element layer, respectively creating spatial indexes for the pipeline point element class and the pipeline element class, calculating the grid range of the pipeline element, and storing grid codes.

3. The method of claim 1, wherein after obtaining the pipeline name of the pipeline data according to the first preset condition, the method further comprises:

searching a second pipeline auxiliary line corresponding to the pipeline data according to the pipeline name;

and deleting the second pipeline auxiliary line and initializing the layer of the pipeline data.

4. The method of claim 1, wherein the first preset condition comprises at least one of:

a geographic location of the pipeline;

and/or, the material of the pipeline;

and/or, the size of the pipeline.

5. The method of claim 1, wherein the second preset condition comprises at least one of:

the use of the pipeline;

and/or, the extent of use of the pipeline.

6. An apparatus for generating a pipeline auxiliary line, comprising:

the pipeline data acquisition module is used for acquiring the pipeline name of pipeline data according to a first preset condition, wherein the pipeline data comprises a plurality of sections of pipelines and pipeline marks;

the pipeline coordinate acquisition module is used for carrying out space query on the pipeline data according to a second preset condition and determining the space coordinate of the pipeline according to a space reference coordinate system;

the index creating module is used for creating a pipeline class and adding an element class index according to the pipeline class, wherein the pipeline class is created according to the type of the pipeline data and the information of the spatial coordinates;

the characteristic point calculation module is used for calculating the characteristic points of the pipeline auxiliary line according to the space coordinates of the pipeline and the element class indexes;

a first auxiliary line generating module, configured to generate a first pipeline auxiliary line according to the feature points of the pipeline auxiliary line, and add the pipeline marker to the corresponding first pipeline auxiliary line;

each section of the pipeline comprises a first endpoint and a second endpoint;

the feature point calculation module includes:

a first feature point calculation submodule, configured to calculate a first feature point of the pipeline auxiliary line according to the first endpoint and the element class index, where the first feature point is obtained by translating the first endpoint toward a normal direction of the pipeline, and a distance of translation is a radius of the pipeline;

a second feature point calculation sub-module, configured to calculate a second feature point of the pipeline auxiliary line according to the second endpoint and the element class index, where the second feature point is obtained by translating the second endpoint toward a normal direction of the pipeline, and a distance of translation is a radius of the pipeline;

the generating of the first auxiliary line according to the feature points of the pipeline auxiliary line by the first auxiliary line generating module specifically includes: and connecting the generated first characteristic point and the second characteristic point.

7. An electronic device, comprising: processor, memory and a computer program stored on the memory and being executable on the processor, the computer program realizing the steps of the method according to any of the claims 1-5 when executed by the processor.

8. A computer-readable storage medium, on which a computer program is stored which, when being executed by a processor, carries out the steps of the method according to any one of claims 1 to 5.

Images