CN100412902C - Information Extraction Method of Graphic Image Data - Google Patents

Abstract

A method for extracting graphic and image data information, importing graphic and image files (BMP files, such as paper files, scanning to generate BMP files) to this program, displaying on the computer screen, the user selects the position where the data information needs to be taken by mouse operation (take During the pointing process, the graphic image can be reduced, enlarged and moved at will), and the program automatically records the data information of the sampling point (screen coordinates and other information of the sampling point). After the sampling is completed, the program converts the screen coordinates into actual coordinates. The advantage of the present invention is that: this work is generally done manually at present, and manual operation is boring, inefficient, time-consuming, inaccurate, and has a high error rate; the present invention is completed by a computer, which greatly improves the efficiency of extraction work and the accuracy of data information. Accurate extraction of coordinate information is realized to ensure that the selected point is displayed in a matching manner with the point on the original image in subsequent graphic image operations (enlargement, reduction, translation), and has a user-friendly operation interface.

Description

Information Extraction Method of Graphic Image Data

technical field

The present invention relates to a method for extracting graphic image data information, in particular to a method for extracting data information from graphic images with no less than three known coordinate data. When the user selects a position with the mouse, the program calculates the position coordinates .

Background technique

In scientific research and production practice, it is often necessary to extract a large amount of data information from graphics and images. This work is now generally done manually, and manual operations are boring, inefficient, time-consuming, imprecise, and have a high error rate. The design program and development software of the present invention are completed by a computer, which greatly improves the efficiency of extraction work and the accuracy of data information.

Contents of the invention

The object of the present invention is to provide such a method for graphic image data information extraction: the graphic image file is imported (BMP file, if it is a paper file, scan to generate a BMP file) program, displayed on the computer screen, and the user selects the desired file by mouse operation. The position of the data information is taken (the graphic image can be zoomed out, enlarged and translated at will during the point taking process), and the software automatically records the data information of the sampling point (screen coordinates and other information of the sampling point). After the sampling is completed, the program converts the screen coordinates into actual coordinates.

The object proposed by the present invention is achieved through the following schemes:

A method for extracting graphic and image data information, used to receive the input of a graphic and image file as the data information of the extraction object, extract the data information and provide the coordinates of the position of the data information, the method includes:

a. Use the mouse to select the position where the data information needs to be taken, and

b. Match and display the location where the data information is taken with the graphic image, and calculate the coordinates of the location where the data information is taken.

This method is used to select the position where the data information needs to be taken by using the mouse: use the Win32API function of operating DIB to display the graphic image bitmap file with the data information on the computer screen, and use the mouse to select the position where the data information needs to be taken , the program records the position.

The method of matching and displaying the position of the data information with the graphic image is adopted: when the program records the position, two two-dimensional dynamic linked lists are used, one records the position when the bitmap file is input, and its corresponding The coordinates on the map, and then when the program draws the coordinate position, calculate the coordinates after coordinate conversion on the map; another linked list is used for saving.

Calculating the coordinates of the position where the data information is taken adopts such a method: on the image of the graphic image bitmap file with the data information displayed on the computer screen, the reference points of the coordinates on the three known maps are selected by the mouse, Input the actual coordinates through the reference point coordinate dialog box, then the mapping relationship between the coordinates on the map and the actual coordinates of all the coordinate positions of the data information will satisfy the mapping relationship of the three reference points.

It is a dynamic random process that the user selects the position of the data information to be collected or deletes the selected position through the mouse operation. The program records the coordinates of the selected position in the dynamic two-dimensional linked list to realize the selection of the data information to be collected by the mouse operation. Randomizes the position or removes the selected position.

Combine the graphs of the three reference points and the actual X and Y coordinates to obtain a system of equations comprising six unknown coefficients and six linear equations, solve the system of equations to obtain six coefficients, and substitute them into each data point The actual coordinates corresponding to each data point can be obtained from the mapping relationship between the actual coordinates and the coordinates on the map. The equation set is as follows:

x1＝A*x01+C*y01+Ly1＝B*x01+D*y01+Mx2＝A*x02+C*y02+Ly2＝B*x02+D*y02+Mx3＝A*x03+C*y03+ Ly3＝B*x03+D*y03+M

Among them (x01, y01), (x02, y02), (x03, y03) are the coordinates on the map of the three reference points respectively, and (x1, y1), (x2, y2), (x3, y3) are three The actual coordinates of the reference point, A, B, C, D, L, M are the unknown coefficients to be solved.

The graphic image file is a BMP bitmap file.

Beneficial effects of the present invention:

1, the present invention is aimed at in scientific research and production practice, the work of extracting data (information) from graphic image is extremely frequent, this actual situation that workload is very large, adopts computer technology (as C++ programming technology), design and develop software, make Users are freed from the "manual extraction" in the past, improving the efficiency of extraction work and the accuracy of data information.

2. The present invention solves the problem of matching and displaying the position selected by the mouse operation with the position on the original image in subsequent graphic image operations (enlargement, reduction, translation).

3. Accurate extraction of coordinate information is implemented in the program, which has strong portability. The data can be extracted from any image file containing data information.

Description of drawings

Figure 1 is a flow chart of the method of the present invention.

Figure 2 is a schematic diagram of the bitmap read-in and display program.

Fig. 3 is an explanatory diagram of a two-dimensional dynamic linked list.

Detailed ways

The present invention will be described in more detail below in conjunction with the accompanying drawings and non-specific embodiments.

Example 1

The present invention will be described in more detail below by taking a BMP bitmap file as an example.

There are two major types of bitmap formats under the Windows operating system - GDI (Graphics Device Interface, graphics device interface) bitmap and DIB (Device-Independent Bitmaps, device-independent bitmap). In MFC (Microsoft Foundation Class, Microsoft Basic Class Library) version 6.0, GDI bitmap objects are encapsulated in the CBitmap class. Because this class uses a Windows data structure related to the Windows GDI module, it is device-dependent. Even if the program gets a copy of the bitmap data, the bit arrangement is still dependent on the display hardware. Therefore, GDI bitmaps can be freely transferred between different programs in the same computer, but their device dependence makes their transfer between different types of computers via disk or network meaningless.

DIB provides many advantages over GDI bitmap in program design: DIB itself carries its own color information, which makes color matching management easier; any computer running Windows operating system can process files stored in BMP or executable DIB in the internal resources of the file; although image files in formats such as TIFF, GIF, or JPEG can also be used after conversion, only files in the DIB format are directly supported by the Win32 API; The bitmap is transferred by passing the GDI bitmap handle to the clipboard, but the operation in the background is done with the help of DIB-converting the device-related GDI bitmap into a DIB and copying the DIB to A shared memory. It can be clearly seen that DIB, which is relatively independent of equipment, has obvious advantages over GDI bitmap. Therefore, the program implementation codes of the image operation part of this software all use DIB as the processing object.

BMP file is a typical one in DIB, and its file format can be divided into two parts: the file header part and the pixel dot matrix part. The file header contains the structural data of the DIB and can be further divided into three sections.

The first part of the file header is the bitmap file header structure BITMAPFILEHEADER, which is defined in wingdi.h as follows:

typedef struct tagBITMAPFILEHEADER {//bmfh

WORD bfType;

DWORD bfSize;

WORD bfReserved1;

WORD bfReserved2;

DWORD bfOffBits;

}BITMAPFILEHEADER;

Its length is fixed at 14 bytes. The first data member bfType is fixed to 0x424D (ASCII code "BM"), which is used to identify this file as a BMP bitmap file. Data member bfSize records the actual length of this bitmap file. bfReserved1 and bfReserved2 are reserved words, usually 0, and generally not considered. The last bfOffBits is the offset distance of the bitmap array relative to the file header.

The second part is the bitmap information header structure BITMAPHEADER, which is also defined in wingdi.h. It has many internal members and mainly records information such as the size and color format of the DIB. The complete definition is as follows:

typedef struct tagBITMAPINFOHEADER {//bmih

DWORD biSize

LONG biWidth;

LONG biHeight;

WORD biPlanes;

WORD biBitCount;

DWORD biCompression;

DWORD biSizeImage;

LONG biXPelsPerMeter;

LONG biYPelsPerMeter;

DWORD biClrUsed;

DWORD biClrImportant;

}BITMAPINFOHEADER;

Among them, the member biSize is the length of the structure, which is fixed at 40 bytes. biWidth and biHeight save the width and height of the DIB respectively. biPlanes describes the number of planes of the target device and must be 1. biBitCount records the bit depth of the image, the optional value is 1 (monochrome bitmap), 4 (16-color bitmap), 8 (256 bitmap), 16 (16-bit enhanced color bitmap), 24 (24-bit true color bitmap) and 32 (32-bit true-color bitmap). BiCompression specifies the compression format of the image, and the valid values are BI_RGB, BI_RLE8, BI_RLE4, BI_BITFIELDS, and BI_JPEG, etc. Generally, it is set to BI_RGB without compression mode. The member biSizeImage is the size of the bitmap array. biXPelsPerMeter and biYPelsPerMeter specify the resolution of the target device. biClrUsed specifies the number of colors actually used in the image, if zero, the colors used are consistent with those specified by the bit depth. The last member, biClrImportant, if non-zero, specifies the relative importance of colors in the image.

The last section is used to store the palette of the image (also known as the color allocation table, color table), so there will be no such section in the header file for 16-bit, 24-bit and 32-bit bit depth images that do not require palette support. Immediately after the first two paragraphs is the pixel array data. For images below 16 bits, this segment is an array of RGBQUAD structures with a length of biClrUsed. The RGBQUAD structure is defined as follows:

typedef struct tagRGBQUAD {//rgbq

BYTE rgbBlue;

BYTE rgbGreen;

BYTE rgbRed;

BYTE rgbReserved;

}RGBQUAD;

The first three members of the structure are the blue, green, and red components of the color, and rgbReserved is a reserved value, usually 0.

After this is the pixel matrix sequence of the image, which has different definitions according to the bit depth. For images with a bit depth below 16 bits, it is the index value of the color; for 16-bit, 24-bit and 32-bit images, the actual R, G, and B component values of the image are stored. Even if it is a true color bitmap, the array structure is different due to the different bit depth. The 16-bit bit depth image adopts the "565" organization method, that is, stores an RGB unit in two bytes: RRRRRGGG (high byte) GGGBBBBB (low byte). A 24-bit bit depth image can just use three bytes to store a complete RGB unit, so when operating on pixels, it can be conveniently processed by bytes without bit operations. The composition principle of the 32-bit bit depth bitmap is also relatively simple. It is realized by expanding a color word into a double word. For example, the above-mentioned 16-bit bit depth image stores two bytes of a complete RGB color. After converting to a 32-bit bit depth bitmap, it is expanded to 00000RRRRRR00000 GGGGGG00 000BBBBB.

In the image processing part, the present invention focuses attention on the algorithm realization of image processing, encapsulates some important DIB access functions provided by the Windows system, and establishes a class to realize the main operation functions of DIB. When performing image processing programming, you only need to call the public interface function provided by this class to realize related functions.

There are five basic functions: SetDIBitsToDevice(), StretchDIBits(), GetDIBits(), CreateDIBitmap(), and CreateDIBSection(), which are used to display and print DIBs, stretch and display DIBs, construct DIBs from GDI bitmaps, and create GDI bits from DIBs diagrams and create DIB items (a special kind of DIB).

The SetDIBitsToDevice() function is responsible for displaying the DIB directly to the screen or outputting it to the printer without any scaling. The function prototype is declared in wingdi.h as follows:

int SetDIBitsToDevice(

HDC hdc, //Device context handle

int XDest, //X coordinate of the upper left corner of the destination area

int YDest, //Y coordinate of the upper left corner of the destination area

DWORD dwWidth //Source DIB width

DWORD dwHeight, //source DIB height

int XSrc, // X coordinate of the upper left corner of the source DIB

int YSrc, //Y coordinate of the upper left corner of the source DIB

UINT uStarScan, //Specify the start line of DIB scanning

UINT cScanLines, //Specify the number of scan lines

CONST VOID*lpvBits, //Pointer to DIB data image

CONST BITMAPINFO*lpbmi, //Pointer to bitmap information structure

UINTfuColorUse // specifies whether to use RGB or color palette // board index

);

The stretch display function StretchDIBits() stretches and transforms the DIB and then displays it on the monitor or outputs it to the printer. The function prototype is as follows:

int StretchDIBits(

HDC hdc, //Device context handle

int XDest, //X coordinate of the upper left corner of the destination area

int YDest, //Y coordinate of the upper left corner of the destination area

int nDestWidth, //Destination area width

int nDestHeight, //Destination area height

int XSrc, // X coordinate of upper left corner of source DIB

int YSrc, //Y coordinate of the upper left corner of the source DIB

int nSrcWidth, //source DIB width

int nSrcHeight, //source DIB height

CONST VOID*lpBits, //Pointer to DIB data image

CONST BITMAPINFO*lpBitsInfo, //Pointer to bitmap information structure

UINT iUsage, // specify whether to use RGB or color palette // color palette index

DWROD dwRop //Specify the drawing method

);

If the signs of the parameters nSrcWidth and nDestWidth or parameters nSrcHeight and nDestHeight are different, the function StretchDIBits() will create a mirror image of the original bitmap. Specifically, if only the signs of the parameters nSrcWidth and nDestWidth are different, a mirror image will be created along the X axis; similarly, if only the signs of the parameters nSrcHeight and nDestHeight are different, a mirror image will be created along the Y axis.

So far, Microsoft has not encapsulated the API functions related to DIB into MFC, which will be very inconvenient when doing object-oriented (OOP) programming. When the author implements programming in this part, he mainly refers to the reference "Visual C++ Implementation of Digital Image Processing" (edited by Lang Rui, Beijing Hope Electronic Publishing House, first edition in January 2003, ISBN7-89498-026-9) related program code. The software source program of the present invention is accompanied by detailed annotations. The MFC provided by Microsoft encapsulates the Windows API and is an object-oriented encapsulated C++ class library. The MFC 6.0 version encapsulates about 200 classes, some of which can be used directly by users, while others are mainly used as the base classes of users' own classes. MFC is an application framework. More than just a collection of classes, it helps define the structure of the application and handles a lot of chores for the application. Frameworks provide abstraction functionality that goes far beyond the capabilities of the Windows API.

The program of the present invention is based on the MFC class library, and the display of the BMP bitmap can be realized by calling the aforementioned DIB class; the parameter of calling the DIB class object function is changed in an appropriate message function to realize the scaling and translation of the bitmap. On this basis, programming realizes other operations, such as mouse click (obtaining data information), data information recording, conversion coordinate calculation, and subsequent graphic image operations (enlargement, reduction, translation) of the acquired points, which are similar to those on the original image. Matches for that point are displayed, etc.

The extraction of graphics and image data information ultimately comes down to the processing of BMP bitmaps. The basic functions of the program are as follows:

In the single-document program automatically generated by MFC Wizards, add the aforementioned DIB class, and instantiate the DIB class in the document class object (named CBMPDoc) of the single-document program, and the object name is m_DIB. In the member function OnOpenDocument () of the CBMPDoc class object, call the member function of reading the DIB file of the m_DIB object to realize the reading of the bitmap file in the single-document MFC program.

After reading in the bitmap file, the display work is completed by the derived class object CBMPView of the MFC CView class. The drawing of the view area of the MFC program window is realized by the member function OnDraw() of the CBMPView class object. In the member function OnDraw() of the CBMPView class object, first call the member function GetDocument() of the CBMPView class object to obtain the pointer to the CBMPDoc class object, use the pointer to point to the m_DIB object in the CBMPDoc object, and then in the OnDraw() function Use the pointer to m_DIB to call the display member function of the DIB class to display the bitmap. As shown in Figure 2 of the description.

When performing bitmap zooming and translation operations, add a new menu in the MFC program menu item, and draw corresponding new tool buttons in the toolbar, corresponding to the zoom factor variable and X, Y axis translation pixel variable respectively. Still in the OnDraw function of the CBMPView class object, change the parameters of the display function passed in to m_DIB, then the DIB class calls the encapsulated Win32API function StretchDIB() to realize the scaling of the bitmap; or change the coordinates of the area where the bitmap is drawn to realize bitmap The panning of the graph. The program and notes are as follows:

CBMPDoc*pDoc＝GetDocument();//Get the pointer of CBMPDoc ASSERT_VALID(pDoc); CRect m_Rect; GetClientRect(m_Rect);//Get the size of the current view area int Draw_Left, Draw_Top;//Draw the coordinates of the upper left corner of the DIB Draw_Left=( m_Rect.Width()-int(pDoc->m_Dib.Width()*amplifier))/2+x_move;//Calculate the X coordinate of the upper left corner, m_Rect.Width() is the width of the current view area, //pDoc is the point CBMPDoc pointer, pDoc->m_Dib.Width() to get the width of the DIB, //amplifier is the defined zoom factor, x_move is the translation distance in the X direction Draw_Top=(m_Rect.Height()-int(pDoc->m_Dib.Height( )*amplifier))/2+y_move;//Same as the previous comment, calculate the Y coordinate of the upper left corner pDoc->m_Dib.Draw(pDC, Draw_Left, Draw_Top, amplifier);//Draw DIB

When dragging and dragging the mouse to realize the translation operation of the bitmap, first define a bool state variable. When the user clicks the menu option or the corresponding toolbar button of the translation operation, the value of the state value is true, and the message function OnLButtonDown of the CBMPView class object In () (representing the left mouse button is pressed), record the coordinates of the current click point, and use the function to capture the movement of the mouse (see the program list for details of the function); press the left mouse button and the mouse moves (drag) process Among them, the message function OnMouseMove() of the CBMPView class object responds to this process, detects whether the mouse is captured, and calculates the values of the variable translation distance variables x_move and y_move from the coordinates of the click point recorded in the OnLButtonDown() function, and refreshes them immediately (Invalidate () function) display, it can display the position of the bitmap moving with the dragging of the mouse; finally, release the left mouse button, the message function OnLButtonUp() responds to this process, releases the capture of the mouse, and completes a translation of the bitmap by dragging the mouse operate.

Since the operation of adding curves, selecting data points and deleting data points by the user is a dynamic random process, it is impossible to know in advance how many data points the user will select and delete or how many curves will be added, so the storage of data points is realized by a two-dimensional linked list. The linked list structure is shown in Figure 3 of the specification.

The linked list is composed of classes, and each node is a class object. This class includes a user-defined type of data field data, which is defined as CPoint type in this software; two pointers of this class, one pointing to the node object of the next "row", and the other pointing to the next "column" The node object.

The linked list includes the header pointer *first, its data field data is set to zero, the "row" pointer points to the first "row", and the "column" pointer (element pointer) refers to empty (NULL); the data field of the head node of each row also Set to zero, the "row" pointer points to the head node of the next "row", and the element pointer points to the first node of the "row"; the "row" pointers of all nodes in each "row" are empty, and the element pointer Point to the next node of the "row", and the data field stores CPoint type data; if it is the last node in the "row", its "row" and "column" pointers are empty; the header node of the last "row" The point is pointed to by the pointer *cur_row, indicating that the "row" is the last row of the linked list, and the last node of the row is pointed by the pointer *cur_ele, indicating that the node is the last node of the last row of the linked list.

The class definition and annotations of the linked list are as follows:

class ChainNode{ //head node class definition friend Chain; private: CPoint data; //data areaChainNode*row, *ele; //pointer of the row and element public: ChainNode(): row(0), ele(0) {}}; class Chain {private: ChainNode*first, *cur_row, *cur_ele; //first, current row, public: // current element pointerChain(); ~Chain(); void /Cele&point add element in current rowvoid add_row(); //add a rowvoid del(const CPoint&point); //deleteint get_row_num(); //count the number of rowsint get_ele_num(const int int&row); current rowCPoint&out(const int&i, const int&j); //output the element at(x,y)};

Based on the two-dimensional dynamic linked list, calling the corresponding member function of the linked list in the response function of the MFC program can dynamically realize the addition and deletion of curves and data points.

When adding a curve, it is equivalent to adding a new "row" in the two-dimensional linked list; when adding a data point, that is, adding a new node in the current "row", and the data field of the node is the selected coordinate; when deleting, because It is impossible to precisely click on the point that needs to be deleted. It is necessary to search the entire linked list first to find the node whose data field is closest to the selected point, and then determine whether the value of the node’s data field and the coordinates of the selected point are within a certain range In order to finally determine whether the node is a node that should be deleted, if so, delete it, and complete the operation of deleting a node, if not, cancel the operation.

In order to realize the matching display of the selected points when the bitmap display changes, when zooming or panning the bitmap, the position of the displayed content will change. At this time, it is necessary to make the data points selected by the user (immediate display) simultaneously Matching display without "misplacement" phenomenon. To solve this problem, the author actually uses two "synchronized" two-dimensional dynamic linked lists when storing data points.

First, there is a switch variable that indicates the state of selecting data points. When the left mouse button is pressed, the function of selecting coordinate points is called. This function updates two linked lists at the same time, one named Current_Points, which is directly stored in the current mouse click point. Coordinates, another named Real_Points, its value is:

Real_Points.out(i,j).x=int(float(Current_Points.out(i,j).x-ccp.x)/amplifier+m_Rect.Width()/2); Real_Points.out(i,j) .y=int(float(Current_Points.out(i,j).y-ccp.y)/amplifier+m_Rect.Height()/2);

Among them, out() is a member function of the two-dimensional dynamic linked list; ccp is the center coordinate of the currently displayed bitmap (it needs to be updated immediately in the OnDraw() function); amplifier and m_Rect are as mentioned above.

It can be seen that what Real_Points actually records is the corresponding coordinates on the map at that time when the selected data point is loaded into the bitmap. Then, when drawing these selected coordinate points in the OnDraw() function, only need to calculate the coordinates of Current_Points after the Real_Points converted coordinates, and the required matching display can be realized.

In addition, the size of the window is variable. When loading the bitmap, the center of the bitmap is always at the center of the window. Therefore, when the window size changes, the value of Real_Points changes accordingly. MFC has a message function OnSize() that handles window changes, and its function parameter is the changed value. Then the calculation method of Real_Points is to change the two corresponding values of m_Rect in the above expression into the two coordinate parameters of the OnSize() function.

The method to realize reference point selection, deletion and matching display is the same as the above method, even simpler, because only three reference points are needed, so it is only necessary to define a one-dimensional array containing three elements, no need to use two Dimensional linked list to achieve.

The input of the actual coordinates of the reference point is realized through an MFC dialog box. Make a dialog instance in MFC, which contains EditBox controls, each control corresponds to the X or Y coordinate value of a reference point, and record the actual coordinates of the three reference points.

Since the coordinates on the map (taken by the user through the mouse) and actual coordinates (input by the user through the dialog box of reference point coordinates) of the three reference points are known, the mapping relationship between the coordinates on the map and the actual coordinates of all data points satisfies The mapping relationship of the three reference points. Combine the graph and actual X and Y coordinates of the three reference points to obtain a system of equations including six unknown coefficients and six linear equations, solve the system of equations to obtain six coefficients, and substitute them into the actual coordinates of each data point The actual coordinates corresponding to each data point can be obtained from the mapping relationship with the coordinates on the graph. The equation set is as follows:

x1＝A*x01+C*y01+Ly1＝B*x01+D*y01+Mx2＝A*x02+C*y02+Ly2＝B*x02+D*y02+Mx3＝A*x03+C*y03+ Ly3＝B*x03+D*y03+M

Among them (x01, y01), (x02, y02), (x03, y03) are the coordinates on the map of the three reference points respectively, and (x1, y1), (x2, y2), (x3, y3) are three The actual coordinates of the reference point, A, B, C, D, L, M are the unknown coefficients to be solved.

When selecting reference points, the best situation is that all data points to be solved are in the center of the triangular area formed by the three reference points, and the shape of the triangle is as regular as possible. At this time, the accuracy of the solved data is high; If the points are collinear or nearly collinear, the area of the triangle is 0 or approximately 0. When solving linear equations, the value of the coefficient determinant will be very small, and the program can determine the value of the reference point selected by the user according to the value of the determinant. To remind the user whether to re-select the reference point to ensure the accuracy of the calculated data.

The method for extracting graphic image data information described in the present invention is not limited to the use listed in the description and the implementation, it can be applied to various fields suitable for the present invention, and can be used by those familiar with the field Additional advantages are readily realized and modifications are readily realized, so the invention is not limited to the specific details, representative apparatus and devices shown and described herein without departing from the spirit and scope of the general concept defined by the claims and equivalents. A graphical example of the description.

Claims (7)

1. method for extracting graph image data information is used to receive the input as the graphic image file of the data message that extracts object, and data message is extracted and provide the coordinate of the position of data message, and described method comprises:

A. mouse-based operation is selected the position need take data message, and

B. the position of taking data message is carried out showing, calculate the coordinate of the position of taking data message with the coupling of graph image.

2. method for extracting graph image data information according to claim 1, it is characterized in that, mouse-based operation is selected to take the position of data message to adopt such method: the Win32 api function with operation DIB shows the graph image bitmap file that has data message on computer screen, the position of the data message that the mouse-based operation selection need be taked, program writes down this position.

3. method for extracting graph image data information according to claim 1, it is characterized in that, the position of taking data message is carried out showing such method that adopted with the coupling of graph image: when the program record position, use two two-dimentional dynamic link tables, this position of record is when bitmap file is imported, the map reference that it is corresponding, when program is drawn this coordinate position subsequently, the coordinate on the calculating chart after the coordinate conversion; Another chained list is used for preserving.

4. method for extracting graph image data information according to claim 1, it is characterized in that, calculating takes the coordinate of the position of data message to adopt such method: the described reference point of choosing three known map references on the image of the graph image bitmap file that has data message that shows on the computer screen by mouse, by reference point coordinate dialog box input actual coordinate, then all take the mapping relations of the map reference of coordinate position of data message and actual coordinate all to satisfy the mapping relations of three reference point.

5. method for extracting graph image data information according to claim 2, it is characterized in that, the user selects the position of the data message that need take or the position deletion that will select by mouse action be a dynamic stochastic process, the coordinate record of the position that program will have been selected is realized the randomness of the position or the position that deletion has been selected of the data message that the mouse action selection need be taked in the Dynamic Two-dimensional chained list.

6. method for extracting graph image data information according to claim 4, it is characterized in that, actual X, Y coordinate simultaneous will be reached on the figure of described three reference point, obtain comprising the system of equations of six unknowm coefficients and six linear equations, find the solution this system of equations, obtain six coefficients, in the mapping relations formula of the actual coordinate of each data point of substitution and map reference, just can try to achieve the actual coordinate of each data point correspondence respectively.System of equations is as follows:

x1＝A*x01+C*y01+L

y1＝B*x01+D*y01+M

x2＝A*x02+C*y02+L

y2＝B*x02+D*y02+M

x3＝A*x03+C*y03+L

y3＝B*x03+D*y03+M

Wherein (x01, y01), (x02, y02), (x03 y03) is respectively the map reference of three reference point, (x1, y1), (x2, y2), (x3 y3) is respectively the actual coordinate of three reference point, and A, B, C, D, L, M are the coefficient of the demand the unknown of separating.

7. according to the described method for extracting graph image data information of arbitrary claim from 1 to 6, it is characterized in that described graphic image file is the BMP bitmap file.

Images