Multi-granularity interaction module plug-in method and device and storage medium

Abstract

The invention provides a multi-granularity interaction module plug-in method and device and a storage medium, and belongs to the field of oil and gas exploration and development. The method comprises the following steps: S100, defining a multi-granularity plug-in specification; s200, obtaining a plug-in manager, and defining functions of the plug-in manager; and S300, loading the interactive plug-in. The method is suitable for application collaborative management of more and more complex integrated seismic processing and interpretation platforms, the convenience and efficiency of the platform can be improved, the usability of the seismic processing and interpretation platform is greatly improved, the data processing time is shortened, the data processing timeliness is improved, and services are provided for exploration and development of conventional oil gas and coal bed gas.

Description

Technical Field

[0001] This invention belongs to the field of oil and gas exploration and development, and specifically relates to a method, device and storage medium for multi-granularity interactive module plug-in. Background Technology

[0002] With increasingly stringent requirements for seismic exploration technology in oil and gas exploration, seismic processing and interpretation platforms cannot meet the needs of actual production with a single approach. This necessitates that processing platforms integrate specialized functions such as seismic imaging, multi-wave processing and interpretation, pre-stack interpretative processing, structural modeling, and seismic forward modeling. They must also integrate future-oriented automated and intelligent seismic processing and interpretation methods and technologies, develop advanced software functions such as automated processing and global interpretation, and construct a professional application software system for seismic processing and interpretation that can adapt to the application needs of seismic exploration production in different exploration areas across China, forming a competitive software platform. The integrated application requirements of seismic processing and interpretation necessitate the efficient management and organization of multidisciplinary data, including pre-stack data, post-stack data, near-surface model data, velocity model data, well logging data, wellbore geological data, well-connected profile data, well-seismic calibration data, seismic stratigraphic data, sedimentary sequence data, and reservoir characterization data. These data vary significantly in terms of disciplinary scale, application scenarios, graphical display, and interactive operations. Achieving integrated seismic processing and interpretation requires not only efficient management of massive amounts of seismic data but also efficient development across multiple disciplines and applications.

[0003] Currently, there are relatively mature earthquake processing and interpretation platforms both domestically and internationally. However, as the platforms include more and more applications, the difficulty of collaborative development across multiple disciplines and applications is increasing. A reliable method is needed to ensure that each application can be developed independently and that applications can be loaded on demand. Summary of the Invention

[0004] The purpose of this invention is to solve the problems existing in the prior art and provide a multi-granularity interactive module plug-in method, device and storage medium, which is suitable for the efficient parallel development of increasingly complex integrated seismic processing and interpretation platforms. It can effectively reduce the coupling of various applications, improve the portability and maintainability of various applications, and load corresponding functions according to user needs, thereby improving the development efficiency and smooth operation of the seismic processing platform and serving the exploration and development of conventional oil and gas and coalbed methane.

[0005] This invention is achieved through the following technical solution:

[0006] A first aspect of the present invention provides a method for a multi-granularity interactive module plugin, comprising:

[0007] S100 defines the multi-granularity plug-in specification;

[0008] S200, obtain the plugin manager and define the plugin manager's functions;

[0009] S300, loading of interactive plugins.

[0010] A further improvement of the present invention is that:

[0011] S100 defines a multi-granularity plug-in specification, and its specific operations include:

[0012] Define different plugin specifications according to different interactive business requirements, that is, define different plugin interfaces according to the interactive business requirements of different applications;

[0013] The plugin interfaces include the IPlugin interface class, the IView interface class, the IObjectTypeSupport interface class, and the IContextMenuExtension interface class.

[0014] A further improvement of the present invention is that:

[0015] The IPlugin interface class includes five interface functions that need to be implemented by the concrete class, namely:

[0016] void Integrate(): This function is automatically called by the main console after the plugin is loaded but before the main interface is displayed.

[0017] void AfterIntegrate(): This function is automatically called by the main console after the main control interface is displayed.

[0018] void Dispose(): This function is called when the plugin is about to be uninstalled.

[0019] QUuid GetID(): Used to answer the plugin's unique identity;

[0020] QString GetMyInformation()const: Used to answer the plugin's description information.

[0021] A further improvement of the present invention is that:

[0022] The IView interface class includes four interface functions that need to be implemented by the plugin's entry point class, namely:

[0023] bool OpenView(): Used to build the user interface of the plugin and integrate it into the display area of ​​the main console;

[0024] bool CloseView(): Triggered when the main interface is closed, used to unload the plugin's interface from the main interface and release memory, and also used to handle data saving before closing and closing non-modal dialogs;

[0025] bool Show(Pai::objectmodel::CPAIObject*): The scenario in which this is called is that the main console or other plugins pass a handle to a CPAIObject data object model to the current plugin, in the expectation that the current plugin will display this data in a graphical or form-based manner;

[0026] bool Acitive(Pai::objectmodel::CPAIObject*): If multiple CPAIObject data are displayed on the plugin's interface, this interface function is used to set the specified CPAIObject data to an active state.

[0027] A further improvement of the present invention is that:

[0028] The IObjectTypeSupport interface class includes an interface function that the implemented class needs to implement, namely:

[0029] QList <quuid>GetSupportTypeIDs()const: Used to enumerate all supported object types.

[0030] A further improvement of the present invention is that:

[0031] The IContextMenuExtension includes an interface function that the instantiated class needs to implement, namely:

[0032] Bool Handle(pi::objectmodel::CPAIObject*,QMenu*): Adds menu items to the context menu of the passed object.

[0033] A further improvement of the present invention is that:

[0034] The S200 defines a plugin manager, whose specific operations include:

[0035] Configure functions for loading, registering, uninstalling, and querying plugins.

[0036] A further improvement of the present invention is that:

[0037] The loading of the S300 interactive plugin involves the following steps:

[0038] The corresponding plugins are loaded into the plugin manager according to the defined multi-granularity plugin specifications.

[0039] A second aspect of the present invention provides a multi-granularity interactive module plug-in device, comprising:

[0040] The first definition unit is used to define the multi-granularity plug-in specification;

[0041] The second definition unit is used to obtain the plugin manager and define the functions of the plugin manager;

[0042] The loading unit is used to load interactive plugins.

[0043] A third aspect of the present invention provides a computer-readable storage medium storing at least one computer-executable program, which, when executed by the computer, causes the computer to perform the steps in the multi-granularity interactive module plug-in method.

[0044] Compared with the prior art, the beneficial effects of the present invention are:

[0045] This invention is applicable to the exploration and development of conventional oil and gas, primarily based on lithological traps. The key technical aspect is the multi-application collaborative approach within an integrated seismic processing and interpretation platform. This mainly involves establishing a unified application (or process) management center, PaiSubProcessManager. This application management center is a globally unique singleton created after the integrated platform starts, responsible for managing all applications. The type of each sub-application is defined by its degree of coupling with the processing platform, and the application management center manages applications at different levels based on their type.

[0046] This invention is applicable to the collaborative management of increasingly complex integrated seismic processing and interpretation platforms, which can improve the convenience and efficiency of the platform, greatly enhance the usability of the seismic processing and interpretation platform, thereby reducing data processing time and improving the timeliness of data processing, and serving the exploration and development of conventional oil and gas and coalbed methane. Attached Figure Description

[0047] Figure 1 This is a flowchart of a multi-granularity interactive module plugin method in an embodiment of the present invention.

[0048] Figure 2 For the IPlugin interface class;

[0049] Figure 3 It is the IView interface class;

[0050] Figure 4 It is the IObjectTypeSupport interface class;

[0051] Figure 5 It is the IContextMenuExtension interface class. Detailed Implementation

[0052] The present invention will now be described in further detail with reference to the accompanying drawings:

[0053] An integrated seismic processing and interpretation platform typically consists of several applications, including data management, job management, profile display, static correction, seismic imaging, multi-wave processing, structural modeling, and seismic forward modeling. Each component is relatively independent and has different application scenarios. Depending on business needs, different application scenarios can load only a portion of the applications. For example, when a user wants to process data, only the job management application needs to be loaded; when a user wants to view the data processing results, only the profile display application needs to be loaded; when there is a business upgrade requirement, only the core code can be modified, tested, and then loaded into the platform. Based on this, this invention proposes a multi-granularity interactive module plug-in method, which can effectively reduce the coupling between various applications, improve the portability and maintainability of each application, and load the corresponding functions according to user needs, thereby improving the development efficiency and operational smoothness of the seismic processing platform and serving the exploration and development of conventional oil and gas and coalbed methane.

[0054] The multi-granularity interactive module plugin method of this invention mainly defines a multi-granularity interactive business function plugin specification, defining different plugin specifications according to different interactive business requirements; at the same time, a plugin manager is defined to manage the loading, registration, uninstallation, and query functions of plugins; finally, all applications of the earthquake processing and interpretation platform are abstracted into individual plugins, and starting the platform is the process of loading plugins.

[0055]

Example 1

[0056] This invention provides a method for creating multi-granularity interactive module plugins, such as... Figure 1 As shown, it includes the following steps:

[0057] S100 defines the multi-granularity plug-in specification;

[0058] S200, obtain the plugin manager and define the plugin manager's functions;

[0059] S300, loading of interactive plugins.

[0060] This invention is applicable to the exploration and development of conventional oil and gas, primarily based on lithological traps. The key technical aspect is the multi-application collaborative approach within an integrated seismic processing and interpretation platform. This mainly involves establishing a unified application (or process) management center, PaiSubProcessManager. This application management center is a globally unique singleton created after the integrated platform starts, responsible for managing all applications. The type of each sub-application is defined by its degree of coupling with the processing platform, and the application management center manages applications at different levels based on their type.

[0061] This invention is applicable to the collaborative management of increasingly complex integrated seismic processing and interpretation platforms, which can improve the convenience and efficiency of the platform, greatly enhance the usability of the seismic processing and interpretation platform, thereby reducing data processing time and improving the timeliness of data processing, and serving the exploration and development of conventional oil and gas and coalbed methane.

[0062]

Example 2

[0063] S100 defines the multi-granularity plug-in specification.

[0064] To facilitate the development and management of application plugins, it is first necessary to define application plugin development specifications, i.e., a unified development interface. A plugin's interface declares the functionality it supports, also known as a plugin contract. A plugin can support multiple interfaces simultaneously, representing the combination of functionalities it possesses.

[0065] Defining the multi-granularity plugin specification involves the following specific steps:

[0066] Define different plugin specifications according to different interactive business requirements, that is, define different plugin interfaces according to the interactive business requirements of different applications.

[0067] In this embodiment of the invention, the plugin interface includes the IPlugin interface class, the IView interface class, the IObjectTypeSupport interface class, and the IContextMenuExtension interface class. When defining the plugin specification, different plugin interfaces are defined according to the different requirements of the interactive business.

[0068] The IPlugin interface class contains the interfaces that plugins of the earthquake processing and interpretation platform must implement. Only plugins that implement this interface will be recognized by the main control console and automatically loaded.

[0069] The IView interface class contains the interfaces that most plugins need to implement, representing the display functionality for one or more data types.

[0070] The `IObjectTypeSupport` interface class describes which data types a plugin supports. In other words, plugins that implement this interface use it to inform the control panel which data types they are interested in. The vast majority of plugins need to implement this interface.

[0071] The IContextMenuExtension interface class describes the extended processing of the context menu associated with certain data. Plugins that implement this interface class are typically used to add menu items and corresponding functions to the context menu of certain data.

[0072] For example, the project data tree plugin needs to inherit the IPlugin interface class and implement its five interfaces: Integrate(), AfterIntegrate(), Dispose(), GetID(), and GetMyInformation(). Since the plugin does not need to be displayed in the view area, it does not need to inherit the IView class. It needs to inherit the IContextMenuExtension interface class and implement the Handle interface to load the general right-click menu of the tree.

[0073]

Example 3

[0074] IPlugin interface class, such as Figure 2 As shown:

[0075] The IPlugin interface class contains the interfaces that plugins of the earthquake processing and interpretation platform must implement. Only plugins that implement these interfaces will be recognized and automatically loaded by the main control console. The IPlugin interface class is a class that every plugin must inherit from, and it contains five interfaces that every plugin must implement.

[0076] The IPlugin interface class has five interface functions that need to be implemented by the instantiated class, namely:

[0077] void Integrate(): This interface function is automatically called by the main console after the plugin is loaded and before the main control interface is displayed.

[0078] void AfterIntegrate(): This interface function is automatically called by the main console after the main control interface is displayed.

[0079] void Dispose(): This interface function is called when the plugin is about to be uninstalled. It is typically used to release all resources created by the plugin.

[0080] QUuid GetID(): This interface function answers the unique identity of the plugin.

[0081] QString GetMyInformation()const: This interface function answers the plugin's description information.

[0082]

Example 4

[0083] IView interface class, such as Figure 3 As shown:

[0084] The IView interface class contains the interfaces that most plugins need to implement, representing the display functionality for one or more data types.

[0085] The IView interface class has four interface functions that need to be implemented by the plugin's entry class:

[0086] bool OpenView(): This interface function is used to build the plugin's user interface and integrate it into the main console's display area. Typically, this function is automatically called by the double-click event flow of nodes in the project's data tree.

[0087] bool CloseView(): This interface function is triggered when the main interface is closed. It is used to unload the plugin's interface from the main interface and release memory. It is also used to handle data saving before closing and closing non-modal dialog boxes.

[0088] `bool Show(Pai::objectmodel::CPAIObject*)`: This interface function is called when the main console or other plugins pass a handle to a `CPAIObject` data object model to the current plugin, expecting the plugin to display this data graphically or in a form. This interface function is automatically called by the double-click event flow of nodes in the project data tree. Each node in the project data tree corresponds to a `CPAIObject` data object model.

[0089] bool Acitive(Pai::objectmodel::CPAIObject*): If multiple CPAIObject data are displayed on the plugin's interface, this interface function is used to set the specified CPAIObject data to an active state.

[0090]

Example 5

[0091] The IObjectTypeSupport interface class, such as Figure 4 As shown:

[0092] The `IObjectTypeSupport` interface class describes which data types a plugin supports. In other words, plugins that implement this interface use it to inform the control panel which data types they are interested in. The vast majority of plugins need to implement this interface.

[0093] The IObjectTypeSupport interface class has only one interface function that needs to be implemented by the concrete class:

[0094] QList <quuid>GetSupportTypeIDs()const: This interface function enumerates all supported object types.

[0095]

Example 6

[0096] The IContextMenuExtension interface class, such as Figure 5 As shown:

[0097] The `IContextMenuExtension` interface class describes the extended processing of context menus associated with specific data. Plugins that implement this interface class are typically used to add menu items and corresponding functionalities to the context menu of a given set of data. The context menu response logic in the project data tree iterates through all plugins and automatically calls this interface function, allowing each plugin to install menu items onto the context menu. The vast majority of plugins are required to implement this interface.

[0098] The IContextMenuExtension interface class has only one interface function that needs to be implemented by the concrete class:

[0099] Bool Handle(pi::objectmodel::CPAIObject*,QMenu*): This interface function typically adds menu items to the context menu of the passed object.

[0100]

Example 7

[0101] S200, obtain the plugin manager and define the plugin manager.

[0102] The Plug-in Manager is the management class for all plug-ins on the earthquake processing and interpretation platform. It provides functions for loading, registering, uninstalling, and querying plug-ins. The Plug-in Manager also supports hot-swapping of plug-ins.

[0103] The specific operations of the plugin manager include: setting up functions for loading, registering, uninstalling, and querying plugins.

[0104] The plugin manager can be accessed through the data model service entry point, as shown below:

[0105] ::GetObjectModelService()->GetPluginManager()

[0106] The plugin manager internally provides a container for plugin entry class handles to support functions such as registration, unregistration, and querying. There are three main query interfaces: the first is to precisely query by ID and return the IPlugin interface type; the second is to precisely query by ID and return a specified interface type (the interface type needs to be specified via template parameters); and the third is to batch query all plugins that support a specified interface type (the interface type also needs to be specified via template parameters), as follows:

[0107] IPlugin*GetPlugin(const QUuid&ipluginID)

[0108] template <interfacetype>GetInerface(const QUuid&ipluginID)

[0109] template <interfacetype>GetInerfaces(QList <interfacetype>&lstResultPlugins)

[0110]

Example 8

[0111] S300, Loading of interactive plugins

[0112] The loading of interactive plugins is as follows: according to the defined multi-granularity plugin specification, the corresponding plugin is loaded into the plugin manager. After successful loading, the interface function void Integrate() in the plugin's IPlugin interface class will be called immediately to perform some plugin integration initialization work.

[0113] During integration, a small number of plugins will insert their window, menu, and other interface elements into the interface container provided by the main control interface or other plugins. For example, the project management subsystem plugin will insert the data tree into the tab container of the data area provided by the main control interface. Therefore, the interface of this type of plugin will be displayed on the screen along with the main interface. However, most plugins do not need to do this kind of integration. They do not have an interface after loading. Their interface will only be displayed in the interface container provided by the main control interface or other plugins under certain triggering conditions. For example, the workflow editing interface can only be opened to the view area of ​​the main control panel when the user double-clicks the workflow node on the data tree. This function is implemented by defining the IView interface class of the plugin specification.

[0114]

Example 9

[0115] This invention provides a multi-granularity interactive module plug-in device, comprising:

[0116] The first definition unit is used to define the multi-granularity plug-in specification;

[0117] The second definition unit is used to obtain the plugin manager and define the functions of the plugin manager;

[0118] The loading unit is used to load interactive plugins.

[0119] This invention is applicable to the collaborative management of increasingly complex integrated seismic processing and interpretation platforms, which can improve the convenience and efficiency of the platform, greatly enhance the usability of the seismic processing and interpretation platform, thereby reducing data processing time and improving the timeliness of data processing, and serving the exploration and development of conventional oil and gas and coalbed methane.

[0120]

Example 10

[0121] This invention provides a computer-readable storage medium storing at least one computer-executable program, which, when executed by the computer, causes the computer to perform the steps in the multi-granularity interactive module plug-in method.

[0122] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0123] The above technical solution is only one embodiment of the present invention. For those skilled in the art, based on the principles disclosed in the present invention, it is easy to make various types of improvements or modifications, and not limited to the technical solutions described in the specific embodiments of the present invention. Therefore, the foregoing description is only a preferred option and is not restrictive.< / interfacetype> < / interfacetype> < / interfacetype> < / quuid> < / quuid>

Claims

1. A method for creating multi-granularity interactive module plugins, characterized in that, include: S100 defines the multi-granularity plug-in specification; S200, obtain the plugin manager and define the plugin manager's functions; S300, loading of interactive plugins.

2. The method according to claim 1, characterized in that: S100 defines a multi-granularity plug-in specification, and its specific operations include: Define different plugin specifications according to different interactive business requirements, that is, define different plugin interfaces according to the interactive business requirements of different applications; The plugin interfaces include the IPlugin interface class, the IView interface class, the IObjectTypeSupport interface class, and the IContextMenuExtension interface class.

3. The method according to claim 2, characterized in that: The IPlugin interface class includes five interface functions that need to be implemented by the concrete class, namely: void Integrate(): This function is automatically called by the main console after the plugin is loaded but before the main interface is displayed. void AfterIntegrate(): This function is automatically called by the main console after the main control interface is displayed. void Dispose(): This function is called when the plugin is about to be uninstalled. QUuid GetID(): Used to answer the plugin's unique identity; QString GetMyInformation()const: Used to answer the plugin's description information.

4. The method according to claim 2, characterized in that: The IView interface class includes four interface functions that need to be implemented by the plugin's entry point class, namely: bool OpenView(): Used to build the user interface of the plugin and integrate it into the display area of ​​the main console; bool CloseView(): Triggered when the main interface is closed, used to unload the plugin's interface from the main interface and release memory, and also used to handle data saving before closing and closing non-modal dialogs; bool Show(Pai::objectmodel::CPAIObject*): The scenario in which this is called is that the main console or other plugins pass a handle to a CPAIObject data object model to the current plugin, in the expectation that the current plugin will display this data in a graphical or form-based manner; bool Acitive(Pai::objectmodel::CPAIObject*): If multiple CPAIObject data are displayed on the plugin's interface, this interface function is used to set the specified CPAIObject data to an active state.

5. The method according to claim 2, characterized in that: The IObjectTypeSupport interface class includes an interface function that the implemented class needs to implement, namely: QList <quuid> GetSupportTypeIDs()const: Used to enumerate all supported object types.< / quuid> 6. The method according to claim 2, characterized in that: The IContextMenuExtension includes an interface function that the instantiated class needs to implement, namely: Bool Handle(pi::objectmodel::CPAIObject*,QMenu*): Adds menu items to the context menu of the passed object.

7. The method according to claim 1, characterized in that: The S200 defines a plugin manager, whose specific operations include: Configure functions for loading, registering, uninstalling, and querying plugins.

8. The method according to claim 1, characterized in that: The loading of the S300 interactive plugin involves the following steps: The corresponding plugins are loaded into the plugin manager according to the defined multi-granularity plugin specifications.

9. A multi-granularity interactive module plug-in device, characterized in that, include: The first definition unit is used to define the multi-granularity plug-in specification; The second definition unit is used to obtain the plugin manager and define the functions of the plugin manager; The loading unit is used to load interactive plugins.

10. A computer-readable storage medium storing at least one computer-executable program, which, when executed by the computer, causes the computer to perform the steps of the multi-granularity interactive module plug-in method as claimed in any one of claims 1-8.

Images