KR101774878B1 - The method for errors detecting of digitalmap - Google Patents

Abstract

The present invention relates to a method for detecting errors in numerical maps in a web (server-client) environment. According to an embodiment of the present invention, the method for detecting errors in numerical maps in the web (server-client) environment comprises the following steps: retrieving map data from a server; getting inputted with checking setting for checking the map data from a user; transmitting the checking setting to a server and conducting checking on the map data based on the transmitted checking setting; and adding a checking result on a screen without a loss of the present edition map through asynchronous communication.

Description

TECHNICAL FIELD [0001] The present invention relates to a digital map error detection method,

The present invention relates to a digital map error detection method.

A numerical map is a basic spatial data of a geographic information system, and it can cause serious problems when the numerical map data having problems in accuracy and consistency is introduced into an application field. Therefore, there is a need for a method that can efficiently detect and edit an error existing in the digital map according to the user's need.

The object of the present invention is to provide a digital map error detection method capable of automatically detecting an error by setting the inspection reference directly according to the purpose, unlike the conventional commercial GIS software which inspects a problem on a digital map according to a preset value .

A method of detecting a digital map error in a server-client environment according to an embodiment of the present invention includes: loading map data from a server; Receiving a verification setting for checking the map data from a user; Transmitting the inspection setting to the server and performing inspection on the map data based on the inspection setting; And adding the verification result to the screen without losing the current editing map through asynchronous communication.

In one embodiment, the step of loading map data from the server comprises the steps of: the user uploading data in the form of a file to GeoServer; Receiving vector data as GeoJSON type character string data using a WFS service provided by GeoServer; Analyzing the GeoJSON type string provided in Openlayers3 and converting it into graphic data through the Canvas function of HTML5; And creating a new layer on the map with the coordinates of the feature according to the determined coordinate system.

In one embodiment, the step of receiving the verification setting includes: generating a layer having information on the verification target area and setting the layer as a verification area; And setting a reference value for a layer importance, a check item, and a check item with respect to the remaining layers according to a user's selection, wherein the check area layer is a layer in the form of a line string, Set the area inside the line as the check area as the same line object.

In one embodiment, the step of inputting the acceptance setting step further includes the step of displaying a reference value or a relation with another layer, the reference value being a reference for error detection according to the acceptance item on the screen, by the user.

In one embodiment, the step of receiving the acceptance setting includes storing the settings of the acceptance items in a JavaScript as a JSON object, including the feature information of a layer converted into GeoJSON through Openlayers3, And transmitting.

In one embodiment of the present invention, the performing of the validation includes: validating the validity of the GeoJSON object by receiving a validation object of the GeoJSON type in the validation module of the GeoJSON object; And verifying the validity, and classifying the object having no fault and the object having no object separately, and transmitting the classified object to the Error JSON generating module or the GeoTools object converting module, respectively.

In one embodiment, the performing of the validation may further include, in the Error JSON generating module, representing an error GeoJSON object received from the GeoJSON object validity testing module as an error object on the Web.

In one embodiment, the step of performing the validation includes converting the GeoJSON object, which is valid after validation in the GeoJSON object validation module, into a SimpleFeatureCollection object of GeoTools available in the GeoTools object conversion module, The GeoTools is a Java library for spatial data representation and computation, and the SimpleFeatureCollection is an object for storing spatial data.

In one embodiment, the step of performing the validation further includes validating the validity of the object converted into the SimpleFeatureCollection object in the GeoTools object validation module. In the GeoTools object validation module, when generating the SimpleFeatureCollection object, Does not generate an error, but finds objects that can cause a spatial operation error when executing the Geometry Validate module.

In one embodiment, performing the validation includes: generating a Validate Layer Data in a Validate Layer Data generation module; In the Validate SimpleFeatureCollection data generation module, generating Validate SimpleFeatureCollection data; And generating a Validate Option object in the Validate Option generating module, wherein the Validate Layer is composed of a SimpleFeatureCollection object storing the spatial data and a Validate Option object storing the acceptance item, and the Validate Layer is a blank value And stored as a new value through the Validate SimpleFeatureCollection creation module and the Validate Option creation module. The Validate SimpleFeatureCollection data means a SimpleFeatureCollection object transmitted from the Validate Layer Data generation module, and the SimpleFeatureCollection object has a plurality of SimpleFeatures A geometry value for storing spatial data, and an attribute value for storing a plurality of attributes. The Validate Option object stores the acceptance item entered by the user and the reference value or the relationship layer value stored in each acceptance item.

In one embodiment, the step of performing the validation includes transmitting a SimpleFeatureCollection stored in each Validate Layer to a corresponding Validate module according to the item of the Validate Option in the Layer Validate module after the Validate Layer object is created ; In the Feature Validate module, the SimpleFeature objects constituting the input SimpleFeatureCollection object are sequentially called and transmitted to a geometry validate module corresponding to a validation item; And performing a spatial operation according to each inspection item using the geometry object and the reference value constituting the transmitted SimpleFeature object in the geometry validate module.

In one embodiment, the error items to be validated by the Geometry Validate module include an EntityDuplicated, a Small Area, an Attribute Fix, an Outboundary, Con Break, Cont Intersected, Contour Line Useless Point, Con Over Degree, Z_Value Ambiguous, Duplicated Point, Allowed A sub-range length error module, at least one of an error module (Small Length), a self-entity, an under-shooting error, and an overshoot error.

In one embodiment, the step of performing the verification includes generating a SimpleFeature object classified as an error as an error feature including a center coordinate value and an error type in the error feature generation module, Is generated only when an error is detected, and all error features that are generated in the acceptance item are collected and created as one SimpleFeatureCollection object.

In one embodiment, the step of performing the verification includes generating an Error Report object including a center coordinate value and an error type of the error SimpleFeatureCollection as an Error Report object in the Error Report generation module, Error Report objects are collected and created as one Error Report object list.

In one embodiment, the step of performing the validation may further include converting the SimpleFeatureCollection object generated through the Error Feature generation module into a GeoJSON object for rendering on the Web in the GeoJSON object transformation module, The GeoJSON object stores information on at least one of an ID of an error object, an error type, an error name, and a coordinate value of an error object.

In one embodiment, the performing of the validation may include: generating an Error Report generation module, an Error GeoJSON object generated through the Error JSON generation module, the Error Feature generation module, and the GeoJSON object conversion module, And generating the generated Error Report object as one Error Layer object. The error GeoJSON object and the Error Report object are generated as one JSON object and added to the viewer as a verification result layer.

In one embodiment, the step of adding the verification results to the screen includes providing an error navigator for verification of the verification result, the error navigator analyzing the verification result layer to determine the location of the error feature and the error name , Allowing them to be queried in order, and providing a link to the error feature and a link to the error feature so that the error feature can be edited via the link.

In one embodiment, the step of adding the acceptance result to the screen includes providing an error report capable of querying the result of acceptance, the error report including an error type, an error name, a layer ID, ID and error coordinates.

A computer program according to an embodiment of the present invention is combined with hardware to execute each step of the above-described digital map error detection method.

According to the embodiment of the present invention, unlike the existing commercial GIS software which checks a problem on a digital map according to a predetermined value, the user can directly detect the error by setting the inspection criterion according to the purpose. All of the above methods are provided as functions available on a web browser, and unlike conventional commercial GIS software that is based on desktop, it has an advantage that it can be used anywhere in the Internet-enabled environment.

1 is a diagram showing the structure of GeoJSON.
FIG. 2 is a diagram showing a verification area definition. FIG.
FIG. 3 is a diagram showing a verification object JSON structure. FIG.
4 is a flowchart showing the acceptance server module.
5 is a diagram showing an error report.

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings, wherein like or similar elements are denoted by the same or similar reference numerals, and redundant description thereof will be omitted. The suffix " module " and " part " for the components used in the following description are given or mixed in consideration of ease of specification, and do not have their own meaning or role. In the following description of the embodiments of the present invention, a detailed description of related arts will be omitted when it is determined that the gist of the embodiments disclosed herein may be blurred. It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory and are intended to provide further explanation of the invention as claimed. , ≪ / RTI > equivalents, and alternatives.

The structured verification according to one embodiment of the present invention means inspection of spatial data. 1. Importing map data, 2. Setting up inspection, 3. Transferring to inspection server, and 4. Adding inspection result. . The detailed steps are as follows.

1. Importing map data

The structured verification tool according to one embodiment of the present invention was developed in accordance with ^each server ⁽¹⁾ environment of a web server. Desktop applications such as ArcGIS or QGIS, which is a commercial program, use vector data in the form of files, but Web-based structured verification tools are not able to access and edit directly from the user's screen (web browser) due to the limitation of web security. Therefore, in order to provide the vector data to be used for the structured verification in a user-editable form in the web environment, it must be converted into a data format suitable for the web environment, and GeoServer ^{footnote (2)} is used as means for solving the data. The Web-based structured verification tool uses the WFS ^{footnote (3)} service provided by GeoServer to upload the vector data to the GeoJSON ^{footnote (4)} type string data as shown in Fig. 1 (1): Client refers to a user or a terminal of a user who uses a service. A server is a computer that provides services and exists for a large number of clients. Web server (IIS, Apache) serves as a server, and the user's web browser (Firefox or MS's Internet Explorer) is the client program. / Footnote (2): GeoServer (GeoServer) is an open source GIS software server developed in Java that allows you to share and edit geospatial data. Because it was developed on the premise that open standards can be used to serve a variety of spatial data sources. / Footnote (3): For the purpose of providing interfaces for the manipulation and processing of geographic feature units using the HTTP protocol / Footnote (4): This is a spatial data exchange format based on JavaScript Object Notation (JSON), which is advantageous in a web environment where JavaScript is frequently used because it employs JavaScript syntax.)

The provided GeoJSON type string is converted into graphic data through the Canvas footnote (6) function of HTML5 by analyzing the string data inside Openlineers3 ^{footnote (5)} . Then, the coordinates of the feature are created as a new layer on the map according to the defined coordinate system. The user then checks the created layer. (Footnote (5): JavaScript-based open source library for outputting and editing maps in a web browser.) Footnote (6): A functional element added to HTML5 that can be used to draw graphics via JavaScript. )

2. Setting the inspection

The user who has confirmed the layer generated by the vector data inputs the setting for inspection to request inspection. First, a layer having information on an area to be inspected is generated and set as a inspection area. The inspection area layer is a line-shaped layer, which means one line object having the same starting point and ending point, and the area inside the line is set as the inspection area. In the case of FIG. 2, the green hatched display area is the inspection area. That is, among the features of all the layers, the feature included in the reference line of the inspection area layer or extending across the line becomes inspection object. Then, the importance of the layer, the inspection item and the reference value for the inspection item are set for the remaining layers.

Table 1 shows 12 items set according to one embodiment. Twelve items detect different kinds of errors.

Inspection item Feature type Reference value SelfEntity Point, LineString, Polygon Layer ID OutBoundary Layer ID AttributeFix Attribute name EntityDuplicated Not applicable PointDuplicated LineString, Polygon Not applicable SmallArea Polygon Width (m²) zValueAmbiguous LineString Attribute name SmallLength Length (m) ConOverDegree Angle (°) ConIntersected Not applicable ConBreak Not applicable UselessPoint Not applicable

The user sets a reference value or a relation with another layer as a reference for detecting an error according to an item on the screen. The structured verification tool according to an embodiment of the present invention is advantageous in that it can be expanded into various forms by allowing the user to directly set the relationship between the criteria of error detection and other layers.

The settings of the above checksums are stored in the JavaScript as JSON ^{footnote (7)} objects. The stored verification object includes the feature information of the layer converted into GeoJSON as shown in FIG. 3 through Openlayers 3 and transmits the information to the server. (7): JavaScript Object Notation (JSON) is a lightweight data-exchange format that allows people to read and write It is also easy for machines to analyze and create, especially when they are exchanging data on the Internet.

3. Transfer to server

The AJAX ^{footnote (8)} sends the verification object in string form to the verification server via the request. As shown in FIG. 4, a total of 14 modules are included in the acceptance server according to an exemplary embodiment of the present invention. (Footnote (8): Asynchronously send and receive information in various formats (JSON, XML, HTML, plain text format, etc.) to the server side, reduce the amount of data received and delegate processing to the client .)

3.1 Validation of GeoJSON Object Validation

In the acceptance server, validation of the GeoJSON object is first checked after receiving the acceptance object of type GeoJSON. The GeoJSON object validation module verifies that it has the correct data structure according to the geometry type. For example, when the Geometry type is a GeoJSON object that is a Polygon, determine whether it has more than 4 coordinate values, whether it is closed, etc. After verifying the validity, classify the faulty object and the non-faulty object separately and send them to 3.3 GeoTools object conversion module, 3.2 Error JSON generation, respectively.

3.2 Creating Error JSON

3.1. GeoJSON object validation module It is a module to express the error GeoJSON object received from the module as an error object on the web. Enter the error type, coordinate value, and error detail information to create a new JSON object and save it. After all checks are completed, it is included in the Error Layer object through 3.14 Error Layer generation module.

3.3 GeoTools object conversion

The GeoTools object conversion module is a module that converts error-free GeoJSON objects into valid GeoTools SimpleFeatureCollection objects in the 3.1 GeoJSON object validation module. GeoTools is a Java library for spatial data representation and computation, and SimpleFeatureCollection is an object for storing spatial data. First, the user obtains the inspection area data entered on the screen. Region layers that are of polygon type have only coordinate values without attributes. After converting the area data into SimpleFeatureCollection object, the spatial data existing in the inspection area is converted. If the user does not check the attribute check item, it is converted into an object having only x and y values. However, when the user checks the attribute check item, it is converted into an object having data attribute as well as x and y values.

3.4 Validating GeoTools Object Validation

After conversion to SimpleFeatureCollection object, validate the converted object. In this module, there is no error when creating SimpleFeatureCollection object, but it detects objects that can cause spatial operation error when executing 3.10 Geometry Validate module. For example, if the coordinates of the polygon are twisted, it is classified as an error object because an error may occur when performing spatial operations with other objects. In this way, the object with the error and the object without the error are classified separately, and the object with the error is sent to the 3.11 Error Feature generation module and the object without the error is sent to the 3.5 Validate Layer Data generation module.

3.5 Generating Validate Layer Data

The Validate Layer consists of a SimpleFeatureCollection object that stores spatial data and a Validate Option object that stores check items. The Validate Layer is stored as a blank value and stored as a new value through the 3.6 Validate SimpleFeatureCollection creation module and the 3.7 Validate Option creation module.

3.6 Creating Validate SimpleFeatureCollection Data

Validate SimpleFeatureCollection data refers to the SimpleFeatureCollection object sent from 3.5 Validate Layer Data generation module. The SimpleFeatureCollection object consists of several SimpleFeatures and stores geometry values for storing spatial data and attribute values for storing various attributes.

3.7 Creating Validate Option

The Validate Option object stores the acceptance items entered by the user and the reference values or relationship layer values stored in each acceptance item. The acceptance items are classified into graphic error and attribute error. First of all, graphic error means a case that is not in conformity with structural errors or numerical mapping rules between spatial data, and it means a case where it is incompatible with the rules of numerical mapping of spatial data, and includes an error such as an undercenter error, an overcorrect error, a boundary over error, contour line disconnection error, contour line cross error, contour straight line untreated error, Error, Duplicate Error, Area Error Below Tolerance, Length Error Below Tolerance, Overlap Error. A reference error, an error exceeding the reference point, a contour line error, an area error below the allowable range, and a range error below the allowable range are stored as reference values of the respective errors. The boundary over error, element redundancy error, and overlap error check the topological structure relationship between the reference layer and the specific layer, and input the relationship layers for checking the phase structure with the reference layer from the user and store them in the Validate Option object. An attribute error occurs when attributes of spatial data stored in the server or attribute data entered directly by the user in the editing tool are missing, or when an incorrect data type or value is input, and consist of an error in altitude altitude value and an error in essential attribute. Attribute Error In addition, the field value of the property to be checked for errors is input from the user and stored as the reference value for inspection.

3.8 Layer Validate

After the Validate Layer object is created, the SimpleFeatureCollection stored in each Validate Layer is transmitted to the corresponding 3.9 Feature Validate module according to the item of Validate Option through the Layer Validate module. For example, when a user inputs spatial data with four layers together with an item to be checked, the user sequentially accesses from the first Validate Layer to the fourth Validate Layer among the four Validate Layers, . If the Validate Option stored in the first Validate Layer is an element duplication error, an area error below the allowable range, or a mandatory attribute error, the SimpleFeatureCollection, the reference value, or the relationship layer from the element duplication error to the mandatory attribute error, The Validate module is called sequentially.

3.9 Feature Validate

In the Feature Validate module, the SimpleFeature objects constituting the input SimpleFeatureCollection object are sequentially called and transmitted to the 3.10 Geometry Validate module corresponding to the verification item.

3.10 Geometry Validate

In the Geometry Validate module, various kinds of spatial operations are performed according to each inspection item using the geometry object and reference value composing the received SimpleFeature object. If the Geometry object does not satisfy the condition of spatial operation, the 3.11 Error Feature generation module is called to create a new SimpleFeature object that stores information such as the center point and error type of the object. Error The SimpleFeature object is used to display an error object on the screen after all checks have been completed. Also, Error Report object is created through 3.12 Error Report generation module which stores detailed information about error SimpleFeature object. The Error Report object collects all the errors that occur during the inspection and is displayed in a list form on the screen.

In the Geometry Validate module, the process of validating an error according to an error item is as follows.

- Element Duplicate Error (EntityDuplicated)

If two data of the same type are duplicated at the same location, it is classified as an error object. It receives SimpleFeature as input data, and checks whether the two SimpleFeatures are overlapped by comparing Geometry type, coordinate values and attribute values.

- Area below allowable range (Small Area)

If the element is less than a certain area, it is classified as an error object. It receives one SimpleFeature object and the area reference value input by the user as input data, and confirms whether the geometry value of the SimpleFeature object has an area smaller than the reference value. Geometry type is Polygon or MultiPolygon only.

- Attribute Fix (Attribute Fix)

If the value of attribute data to be input is not input, it is classified as an error object. The existence of the corresponding attribute value is checked by comparing the attribute value of the SimpleFeature object with the field value of the attribute inputted by the user.

- Outbound error

If the two SimpleFeatures have inconsistent inclusion relations, they are classified as error objects. When you enter the SimpleFeature that is a reference and the SimpleFeature that you want to check for inclusion, you check whether the feature you want to include is over the boundary of the reference feature.

- Contour break error (Con Break)

Determines whether the SimpleFeature of the contour layer conforms to the numerical mapping rules. For contour lines, contour lines of the same height must be non-breaking, so the first point and the endpoint must be the same, or the first point or endpoint must touch the area feature. Therefore, in case of a contour line break error, area layer data is fetched as input data differently from other error items. Geometry types can only be LineString or MultiLineString.

- Con Intersected

Determines whether the SimpleFeature of the contour layer conforms to the numerical mapping rules. If one feature is crossed by itself or intersects another contour feature, it is classified as an error object. Geometry types can only be LineString or MultiLineString.

- Contour Linearization Error (Useless Point)

Determines whether the SimpleFeature of the contour layer conforms to the numerical mapping rules. If the length between consecutive contour lines is less than 3m and the angle is less than 6 degrees, it is classified as an error object. Geometry types can only be LineString or MultiLineString.

- Con Over Degree

Determines whether the SimpleFeature of the contour layer conforms to the numerical mapping rules. If the angle between the points of consecutive contour lines is less than the reference value entered by the user, it is classified as an error object. Geometry types can only be LineString or MultiLinestring.

- contour altitude value error (Z_Value Ambiguous)

Determines whether the SimpleFeature of the contour layer conforms to the numerical mapping rules. It compares the attribute value of the SimpleFeature which is the input data with the field value of the attribute inputted by the user and confirms whether or not the corresponding attribute value exists. If the field attribute makes a logical error, the field attribute is not an integer, and if it is a null value, it is classified as an error object.

- Duplicated Point Module

If two or more points exist at the same position among successive geometry coordinate values of one SimpleFeature, it is classified as an error object.

- Less than allowable length error module (Small Length)

If the line element is less than a certain length, it is classified as an error object. It takes one SimpleFeature object and the length reference value inputted by the user as input data, and confirms whether the geometry value of the SimpleFeature object has a length less than the reference value. The Geometry type can only be a LineString or MultiLinestring.

- Self-Entity

Check whether the two SimpleFeatures intersect. When a SimpleFeature that is a reference and a SimpleFeature to check for intersection are input, it is classified as an error object when a SimpleFeature that checks whether an intersection is overlapped with a reference SimpleFeature.

- Under Shoot Error

If the SimpleFeature that should touch the check area layer does not reach the area, it is classified as an error object. An error below the reference point must have the area layer data as input data. If SimpleFeature is touching the area layer or the distance from the area layer is more than 0.02m, it is classified as error object.

- Over Shoot Error (Over Shoot)

If the SimpleFeature that should be touching the inspection area layer is past the area, it is classified as an error object. The error exceeding the reference point must have the area layer data as input data. If SimpleFeature is touching the area layer or the area layer is over 0.01m, it is classified as the error object.

3.11 Error Feature Generation

SimpleFeature objects classified as errors are created with Error Feature including center coordinate value, error type, and so on. The Error Feature is generated only when an error is detected, and all error features that are generated in the verification item are collected and created as a single SimpleFeatureCollection object. It is then returned with the Error Report object.

3.12 Error Report Generation

Error Creates an Error Report object including the center coordinate value of the SimpleFeatureCollection and the kind of error. All of the Error Report objects generated from the acceptance items are collected and created as one Error Report object list, and finally returned together with the Error Feature object. The Error Feature has the same information as the Error Feature, but the Error Feature is a means for displaying the error object on the screen. The Error Report is a means for displaying the information on the error object to the user in a list format.

3.13 Transforming GeoJSON Objects

The SimpleFeatureCollection object generated through the Error Feature generation module is converted into a GeoJSON object to be displayed on the Web again. Even if multiple layers are input at the time of inspection, one error GeoJSON is returned after inspection. Error GeoJSON stores information about the error object ID, error type, error name, and coordinate value of the error object.

3.14 Error Layer Generation

The Error Layer Generation Module is a module that generates an Error Report object created by the Error Report Generation Module and the Error GeoJSON Object generated through the 3.2 Error JSON Generation, 3.9 Error Feature Generation Module, and 3.11 GeoJSON Object Transformation Module as one Error Layer object to be. Error The GeoJSON object and the Error Report object are created as a single JSON object and added to the viewer as a validation result layer.

4. Adding the verification result

The verification result adds the verification result to the screen through the asynchronous communication ^{footnote (9)} without losing the current editing map. Use the error navigator to check the validation results. The Error Navigator analyzes the validation layer, displays the location and error name of the error feature, and queries it in order. The error navigator edits the error feature over the link by providing a scroll to the error location and a link to the error feature. As shown in FIG. 5, the result of verification is inquired in the error report. In the report, the type of error (indicating whether the error is a structural error of a graphic or an attribute information error), an error name (an item corresponding to the feature in the inspection item), a layer ID (unique identifier of the layer) (A unique identifier of the feature), and error coordinates (coordinates indicating the location of the error). (Footnote (9): Existing web applications fill a form in a browser and submit it to a web server. As a single request, the web server processes the data according to the requested contents to create a new web page, On the other hand, an Ajax application can only request data from the web server and then process the data from the client.)

The above-described present invention can be implemented as a computer program or an application recorded on a medium. The computer readable medium includes all kinds of recording devices in which data that can be read by a computer system is stored. Examples of the computer readable medium include a hard disk drive (HDD), a solid state disk (SSD), a silicon disk drive (SDD), a ROM, a RAM, a CD-ROM, a magnetic tape, a floppy disk, , And may also be implemented in the form of a carrier wave (e.g., transmission over the Internet). Also, the computer may include a control unit of the terminal.

The foregoing detailed description should not be construed in all aspects as limiting and should be considered illustrative. The scope of the present invention should be determined by rational interpretation of the appended claims, and all changes within the scope of equivalents of the present invention are included in the scope of the present invention.

Claims (19)

A method for detecting a digital map error in a web (Server-Client)
Loading map data from a server;
Receiving a verification setting for checking the map data from a user;
Transmitting the inspection setting to the server and performing inspection on the map data based on the inspection setting; And
Adding the verification result to the screen without losing the current editing map through the asynchronous communication,
The step of loading map data from the server comprises:
The user uploading data in the form of a file to GeoServer;
Receiving vector data as GeoJSON type character string data using a WFS service provided by GeoServer;
Analyzing the GeoJSON type string provided in Openlayers3 and converting it into graphic data through the Canvas function of HTML5; And
Generating a new layer on the map of the coordinates of the feature according to a predetermined coordinate system.
delete The method according to claim 1,
The step of receiving the acceptance setting includes:
Generating a layer having information on an area to be inspected and setting the layer as a inspection area; And
And setting a reference value for the importance of the layer, the inspection item, and the inspection item with respect to the remaining layers according to the user's selection,
Wherein the check area layer is a line layer type line object having the same start point and end point as the line area and sets the area inside the line as the check area.
The method of claim 3,
The step of receiving the acceptance setting includes:
And displaying a reference value or a relation with another layer as a reference for error detection according to the acceptance item on the screen so that the user can establish a relationship with the other value.
The method of claim 3,
The step of receiving the acceptance setting includes:
Storing the settings of the inspection items as a JSON object in the JavaScript and transmitting the stored inspection object to the server including the feature information of the layer converted into GeoJSON through Openlayers3.
The method according to claim 1,
The step of performing the inspection includes:
In the GeoJSON object validation module,
Receiving validation object of GeoJSON type and validating the validity of GeoJSON object; And
And validating the validity of the object, and classifying the object having no fault and the object having no object separately, and transmitting the classified object to the Error JSON generating module or the GeoTools object converting module, respectively.
The method according to claim 6,
The step of performing the inspection includes:
In the Error JSON generation module,
And expressing the erroneous GeoJSON object received from the GeoJSON object validation module as an erroneous object on the web.
The method according to claim 6,
The step of performing the inspection includes:
In the GeoTools object transformation module,
And converting the GeoJSON object having no error to GeoTools' SimpleFeatureCollection object available in the GeoJSON object validation module,
Wherein the GeoTools is a Java library for spatial data representation and computation, and the SimpleFeatureCollection is an object for storing spatial data.
9. The method of claim 8,
The step of performing the inspection includes:
In the GeoTools object validation module,
And validating the validity of the object converted into the SimpleFeatureCollection object,
In the GeoTools object validation module, no errors are generated when a SimpleFeatureCollection object is created, but objects that can cause a spatial operation error when performing a Geometry Validate module are found.
9. The method of claim 8,
The step of performing the inspection includes:
Generating a Validate Layer Data in a Validate Layer Data generation module;
In the Validate SimpleFeatureCollection data generation module, generating Validate SimpleFeatureCollection data; And
In the Validate Option generation module, a step of creating a Validate Option object is further included,
The Validate Layer is composed of a SimpleFeatureCollection object storing spatial data and a Validate Option object storing a validation item. The Validate Layer is stored as a blank value, and is converted into a new value through the Validate SimpleFeatureCollection creation module and the Validate Option creation module Stored,
Wherein the Validate SimpleFeatureCollection data refers to a SimpleFeatureCollection object transmitted from the Validate Layer Data generation module, the SimpleFeatureCollection object includes a plurality of SimpleFeatures, stores a Geometry value for storing spatial data, and an Attribute value for storing a plurality of attributes,
The Validate Option object stores the acceptance item entered by the user and the reference value or relation layer value stored in each acceptance item.
11. The method of claim 10,
The step of performing the inspection includes:
Transmitting a SimpleFeatureCollection stored in each Validate Layer to the corresponding Feature Validate module according to the item of the Validate Option in the Layer Validate module after generating the Validate Layer object;
In the Feature Validate module, the SimpleFeature objects constituting the input SimpleFeatureCollection object are sequentially called and transmitted to a geometry validate module corresponding to a validation item;
And performing a spatial operation on each check item using the geometry object constituting the transmitted SimpleFeature object and the reference value in the geometry validate module.
12. The method of claim 11,
The error item to be checked by the geometry validate module is,
EntityDuplicated, Small Area, Attribute Fix, OutBoundary, ConBreak, Cont Intersected, Contour Linearization Untreated Useless Point, Con Over Degree, Z_Value Ambiguous, Duplicated Point, Less Length, Small Length, Self Entity, , An under-shooting error (Under Shoot), and an over-shooting error (Over Shoot).
12. The method of claim 11,
The step of performing the inspection includes:
In the Error Feature generation module,
Generating a SimpleFeature object classified as an error as an Error Feature including a center coordinate value and an error type,
Wherein the error feature is generated only when an error is detected, and all the occurring error features are collected in the acceptance item to generate a single SimpleFeatureCollection object.
14. The method of claim 13,
The step of performing the inspection includes:
In the Error Report generation module,
Generating an Error Report object including a center coordinate value of the error SimpleFeatureCollection and an error type;
A method of detecting a digital map error, comprising: collecting all Error Report objects generated from a verification item and generating a list of Error Report objects;
14. The method of claim 13,
The step of performing the inspection includes:
In the GeoJSON object transform module,
And converting the SimpleFeatureCollection object generated through the Error Feature generation module to a GeoJSON object for rendering on the Web,
Wherein the GeoJSON object stores information on at least one of an ID of an error object, an error type, an error name, and coordinate values of an error object.
16. The method of claim 15,
The step of performing the inspection includes:
In the Error Layer generation module,
Generating an error GeoJSON object generated through the Error JSON generating module, the Error Feature generating module, and the GeoJSON object converting module and an Error Report object generated through the Error Report generating module as one Error Layer object and,
Wherein the error GeoJSON object and the Error Report object are generated as one JSON object and added to the viewer as a verification result layer.
The method according to claim 1,
Wherein the step of adding the verification result to the screen comprises:
And providing an error navigator for verification of the verification result,
The error navigator analyzes the inspection result layer to display the location of the error feature, the error name, and the order of the error feature, and provides a link to the error location and the link to the error feature, To be edited.
The method according to claim 1,
Wherein the step of adding the acceptance result to the screen comprises:
And providing an error report capable of querying results for validation,
Wherein the error report includes at least one of an error type, an error name, a layer ID, a feature ID, and an error coordinate.
18. A computer program stored in a medium for executing each step of a digital map error detection method according to any one of claims 1 to 18 in combination with hardware.

Images