def crc(cls, surface_file, output, crc): """ Compute an XML CRC of a Geosurface file. :param surface_file: Geosurface file :param output: Output file :param crc: CRC (unused, always set to 0) :type surface_file: str :type output: str :type crc: int_ref :returns: CRC Value (always 0) :rtype: int .. versionadded:: 8.0 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ """ ret_val, crc.value = gxapi_cy.WrapSURFACE._crc( GXContext._get_tls_geo(), surface_file.encode(), output.encode(), crc.value) return ret_val
def compute_surface_subdivision(cls, inputSurfaceFile, inputSurface, outputSurfaceFile, outputSurface): """ Smooths a surface by applying a loop subdivision algorithm :param inputSurfaceFile: Input Geosurface file :param inputSurface: Input Surface Name within Geosurface File :param outputSurfaceFile: Output Geosurface file :param outputSurface: Output Surface Name within Geosurface File :type inputSurfaceFile: str :type inputSurface: str :type outputSurfaceFile: str :type outputSurface: str .. versionadded:: 9.5 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ """ gxapi_cy.WrapMESHUTIL._compute_surface_subdivision( GXContext._get_tls_geo(), inputSurfaceFile.encode(), inputSurface.encode(), outputSurfaceFile.encode(), outputSurface.encode())
def gravity_still_reading_correction(cls, db, grav_in, date, time, still, grav_out): """ Gravity Still Reading Correction on selected lines. :param db: Database :param grav_in: Input gravity channel handle [`DB_LOCK_READONLY <geosoft.gxapi.DB_LOCK_READONLY>`] :param date: Input date channel handle [`DB_LOCK_READONLY <geosoft.gxapi.DB_LOCK_READONLY>`] :param time: Input time channel handle [`DB_LOCK_READONLY <geosoft.gxapi.DB_LOCK_READONLY>`] :param still: Still readings file :param grav_out: Output gravity channel handle [`DB_LOCK_READWRITE <geosoft.gxapi.DB_LOCK_READWRITE>`] :type db: GXDB :type grav_in: int :type date: int :type time: int :type still: str :type grav_out: int .. versionadded:: 8.5 **License:** `Geosoft End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-end-user-lic>`_ """ gxapi_cy.WrapGU._gravity_still_reading_correction(GXContext._get_tls_geo(), db, grav_in, date, time, still.encode(), grav_out)
def does_surface_intersect(cls, primarySurfaceFile, primarySurface, secondarySurfaceFile, secondarySurface): """ Checks if the two surfaces intersect at all :param primarySurfaceFile: Primary Geosurface file :param primarySurface: Primary Surface Name within Geosurface File :param secondarySurfaceFile: Secondary Geosurface file :param secondarySurface: Secondary Surface Name within Geosurface File :type primarySurfaceFile: str :type primarySurface: str :type secondarySurfaceFile: str :type secondarySurface: str :returns: Returns 1 if intersects, 0 if surfaces do not intersect :rtype: int .. versionadded:: 9.5 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ """ ret_val = gxapi_cy.WrapMESHUTIL._does_surface_intersect(GXContext._get_tls_geo(), primarySurfaceFile.encode(), primarySurface.encode(), secondarySurfaceFile.encode(), secondarySurface.encode()) return ret_val
def remove_tool(cls, name): """ Removes (and closes if visible) a auxiliary tool from the current project. :param name: Tool name :type name: str :returns: 0 - Ok 1 - Tool not found in project :rtype: int .. versionadded:: 5.0 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ **Limitations:** May not be available while executing a command line program. **Note:** Nothing """ ret_val = gxapi_cy.WrapPROJ._remove_tool(GXContext._get_tls_geo(), name.encode()) return ret_val
def create(cls, name, size_x, size_y, size_z): """ Creates a new Multivoxset :param name: File Name :param size_x: Size in X. :param size_y: Size in Y. :param size_z: Size in Z. :type name: str :type size_x: int :type size_y: int :type size_z: int :returns: `GXMULTIGRID3D <geosoft.gxapi.GXMULTIGRID3D>` handle, terminates if creation fails :rtype: GXMULTIGRID3D .. versionadded:: 9.4 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ """ ret_val = gxapi_cy.WrapMULTIGRID3D._create(GXContext._get_tls_geo(), name.encode(), size_x, size_y, size_z) return GXMULTIGRID3D(ret_val)
def clip_surface_with_polygon2d(cls, inputSurfaceFile, inputSurface, polygonFile, outputSurfaceFile, outputSurfaceName, maskInside): """ Clip a Surface a specified Polygon file :param inputSurfaceFile: Input Geosurface file :param inputSurface: Input Surface name within Geosurface file :param polygonFile: Polygon File :param outputSurfaceFile: Output Surface file :param outputSurfaceName: Output Surface name :param maskInside: Set true if the values inside polygon are to be masked :type inputSurfaceFile: str :type inputSurface: str :type polygonFile: str :type outputSurfaceFile: str :type outputSurfaceName: str :type maskInside: bool .. versionadded:: 9.5 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ """ gxapi_cy.WrapMESHUTIL._clip_surface_with_polygon2d(GXContext._get_tls_geo(), inputSurfaceFile.encode(), inputSurface.encode(), polygonFile.encode(), outputSurfaceFile.encode(), outputSurfaceName.encode(), maskInside)
def create(cls, input): """ Create a filter from a comma/space delimited string. :param input: Filter string :type input: str :returns: `GXFLT <geosoft.gxapi.GXFLT>` Object :rtype: int .. versionadded:: 5.0 **License:** `Geosoft End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-end-user-lic>`_ **Note:** Terminates process if filter not found. Sample Fraser Filter string: "-1,-1,1,1" """ ret_val = gxapi_cy.WrapFLT._create(GXContext._get_tls_geo(), input.encode()) return ret_val
def create_db(cls, db): """ Create a table from a database. :param db: Database :type db: GXDB :returns: `GXTB <geosoft.gxapi.GXTB>` Object :rtype: GXTB .. versionadded:: 5.0 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ **Note:** The table will contain fields for all channels in the database. The database is not loaded with data. Use the `load_db <geosoft.gxapi.GXTB.load_db>` function to load data into the table. """ ret_val = gxapi_cy.WrapTB._create_db(GXContext._get_tls_geo(), db) return GXTB(ret_val)
def get_login_gui(cls, server, user, password, mode, win_auth): """ Get/Test login information to SQL Server :param server: SQL server to use :param user: User name (default & returned) :param password: Password (default & returned) :param mode: :ref:`MFCSQL_DRIVER` :param win_auth: Windows Authentication (default & returned) :type server: str :type user: str_ref :type password: str_ref :type mode: int :type win_auth: int_ref .. versionadded:: 5.1.8 **License:** `Geosoft End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-end-user-lic>`_ """ user.value, password.value, win_auth.value = gxapi_cy.WrapSQLSRV._get_login_gui( GXContext._get_tls_geo(), server.encode(), user.value.encode(), password.value.encode(), mode, win_auth.value)
def create_itr(cls, vox, itr): """ Create a new `GXVOXD <geosoft.gxapi.GXVOXD>` with our own `GXITR <geosoft.gxapi.GXITR>` :param vox: `GXVOX <geosoft.gxapi.GXVOX>` Object :param itr: `GXITR <geosoft.gxapi.GXITR>` Object :type vox: GXVOX :type itr: GXITR :returns: `GXVOXD <geosoft.gxapi.GXVOXD>` handle, terminates if creation fails :rtype: GXVOXD .. versionadded:: 6.2 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ **Note:** Fails if the `GXVOX <geosoft.gxapi.GXVOX>` object is thematic. (See the `create_thematic <geosoft.gxapi.GXVOXD.create_thematic>` function.) """ ret_val = gxapi_cy.WrapVOXD._create_itr(GXContext._get_tls_geo(), vox, itr) return GXVOXD(ret_val)
def create_db(cls, db, x_ch, y_ch, z_ch): """ Create a handle to a database `GXDAT <geosoft.gxapi.GXDAT>` object :param db: Handle to database which `GXDAT <geosoft.gxapi.GXDAT>` is connected with :param x_ch: Name of X channel in database :param y_ch: Name of Y channel in database :param z_ch: Name of Z channel in database :type db: GXDB :type x_ch: str :type y_ch: str :type z_ch: str :returns: `GXDAT <geosoft.gxapi.GXDAT>` Object :rtype: GXDAT .. versionadded:: 5.0 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ """ ret_val = gxapi_cy.WrapDAT._create_db(GXContext._get_tls_geo(), db, x_ch.encode(), y_ch.encode(), z_ch.encode()) return GXDAT(ret_val)
def get_lst(cls, lst, interface, flags, mode): """ Put available `GXDAT <geosoft.gxapi.GXDAT>` filters and qualifiers in a `GXLST <geosoft.gxapi.GXLST>` :param lst: `GXLST <geosoft.gxapi.GXLST>` object to populate :param interface: `GXDAT <geosoft.gxapi.GXDAT>` interface name ("XGD" only support option currently) :param flags: :ref:`DAT_FILE` :param mode: :ref:`DAT_FILE_FORM` :type lst: GXLST :type interface: str :type flags: int :type mode: int .. versionadded:: 5.1.8 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ **Note:** The filters displayed in the Grid/Image file browse dialog are put in the "Name" of the `GXLST <geosoft.gxapi.GXLST>`, while the file qualifiers are stored in the "Value". """ gxapi_cy.WrapDAT._get_lst(GXContext._get_tls_geo(), lst, interface.encode(), flags, mode)
def load_no_activate(cls, name): """ Loads documents into the workspace :param name: List of documents (';' or '|' delimited) to load. :type name: str :returns: Handle to current edited document, which will be the last database in the list if multiple files were provided. :rtype: GXEMAPTEMPLATE .. versionadded:: 5.0 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ **Limitations:** May not be available while executing a command line program. **Note:** This function acts just like `load <geosoft.gxapi.GXEMAPTEMPLATE.load>` except that the document(s) is not activated (brought to foreground) and no guarantee is given about which document is currently active. """ ret_val = gxapi_cy.WrapEMAPTEMPLATE._load_no_activate(GXContext._get_tls_geo(), name.encode()) return GXEMAPTEMPLATE(ret_val)
def is_mi_map_file(cls, map): """ Returns TRUE if file is a MapInfo MAP file. :param map: Name of input map file :type map: str :returns: 0 if not a MapInfo MAP file 1 if it is. :rtype: int .. versionadded:: 5.0 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ **Note:** It is important not to overwrite a MapInfo MAP file with a Geosoft one. Use this function to test the MAP file (looks at the first few bytes). """ ret_val = gxapi_cy.WrapGIS._is_mi_map_file(GXContext._get_tls_geo(), map.encode()) return ret_val
def run_vv(cls, vv_x, vv_y, vv_z, ipj, ctl, grd): """ Executes the Rangrid program directly on input data VVs. :param vv_x: X data :param vv_y: Y data :param vv_z: Z (grid value) data :param ipj: Projection to put into grid :param ctl: RANGRID control file. :param grd: Output grid name :type vv_x: GXVV :type vv_y: GXVV :type vv_z: GXVV :type ipj: GXIPJ :type ctl: str :type grd: str .. versionadded:: 6.3 **License:** `Geosoft Extended End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-ext-end-user-lic>`_ """ gxapi_cy.WrapRGRD._run_vv(GXContext._get_tls_geo(), vv_x, vv_y, vv_z, ipj, ctl.encode(), grd.encode())
def triangulation_to_view(cls, triangulation_file, ipj, mview, new_group_name): """ Draw triangle edges in a Vulcan triangulation file to a 3D view in a map. :param triangulation_file: Triangulation file :param ipj: Triangulation projection :param mview: Destination `GXMVIEW <geosoft.gxapi.GXMVIEW>` :param new_group_name: New group name :type triangulation_file: str :type ipj: GXIPJ :type mview: GXMVIEW :type new_group_name: str .. versionadded:: 8.4 **License:** `Geosoft End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-end-user-lic>`_ """ gxapi_cy.WrapVULCAN._triangulation_to_view(GXContext._get_tls_geo(), triangulation_file.encode(), ipj, mview, new_group_name.encode())
def launch(cls, model): """ Launch `GXGMSYS <geosoft.gxapi.GXGMSYS>` with extension :param model: Model name :type model: str .. versionadded:: 5.0.1 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ """ gxapi_cy.WrapGMSYS._launch(GXContext._get_tls_geo(), model.encode()) ### endblock ClassImplementation ### block ClassExtend # NOTICE: The code generator will not replace the code in this block ### endblock ClassExtend ### block Footer # NOTICE: The code generator will not replace the code in this block ### endblock Footer
def current_no_activate(cls, type): """ This method returns the Current Edited Document. :param type: :ref:`EDOC_TYPE` :type type: int :returns: `GXEDOC <geosoft.gxapi.GXEDOC>` Object :rtype: GXEDOC .. versionadded:: 9.0 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ **Limitations:** May not be available while executing a command line program. **Note:** This function acts just like `current <geosoft.gxapi.GXEDOC.current>` except that the document is not activated (brought to foreground) and no guarantee is given about which document is currently active. """ ret_val = gxapi_cy.WrapEDOC._current_no_activate( GXContext._get_tls_geo(), type) return GXEDOC(ret_val)
def create(cls, type, name): """ Create a `GXSURFACEITEM <geosoft.gxapi.GXSURFACEITEM>` :param type: Type :param name: Name :type type: str :type name: str :returns: `GXSURFACEITEM <geosoft.gxapi.GXSURFACEITEM>` Object :rtype: GXSURFACEITEM .. versionadded:: 8.4 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ .. seealso:: `set_properties <geosoft.gxapi.GXSURFACEITEM.set_properties>` and `set_default_render_properties <geosoft.gxapi.GXSURFACEITEM.set_default_render_properties>` """ ret_val = gxapi_cy.WrapSURFACEITEM._create(GXContext._get_tls_geo(), type.encode(), name.encode()) return GXSURFACEITEM(ret_val)
def compute_surface_intersection(cls, primarySurfaceFile, primarySurface, secondarySurfaceFile, secondarySurface, outputSurfaceFile, outputSurface): """ Computes and outputs the intersection of two closed surfaces :param primarySurfaceFile: Primary Geosurface file :param primarySurface: Primary Surface Name within Geosurface File :param secondarySurfaceFile: Secondary Geosurface file :param secondarySurface: Secondary Surface Name within Geosurface File :param outputSurfaceFile: Output surface file :param outputSurface: Output surface name :type primarySurfaceFile: str :type primarySurface: str :type secondarySurfaceFile: str :type secondarySurface: str :type outputSurfaceFile: str :type outputSurface: str .. versionadded:: 9.5 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ """ gxapi_cy.WrapMESHUTIL._compute_surface_intersection(GXContext._get_tls_geo(), primarySurfaceFile.encode(), primarySurface.encode(), secondarySurfaceFile.encode(), secondarySurface.encode(), outputSurfaceFile.encode(), outputSurface.encode())
def create_sbf(cls, sbf, file, status): """ Create `GXBF <geosoft.gxapi.GXBF>` object inside an `GXSBF <geosoft.gxapi.GXSBF>`. :param sbf: Storage :param file: File name to open ("" is a temporary file) :param status: :ref:`BF_OPEN_MODE` :type sbf: GXSBF :type file: str :type status: int :returns: `GXBF <geosoft.gxapi.GXBF>` Object :rtype: GXBF .. versionadded:: 5.0 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ **Note:** see sbf.gxh """ ret_val = gxapi_cy.WrapBF._create_sbf(GXContext._get_tls_geo(), sbf, file.encode(), status) return GXBF(ret_val)
def create_sbf(cls, sbf, file, append): """ Creates an ASCII file to write to in an `GXSBF <geosoft.gxapi.GXSBF>`. :param sbf: Storage :param file: Name of the File :param append: :ref:`WA_OPEN` :type sbf: GXSBF :type file: str :type append: int :returns: `GXWA <geosoft.gxapi.GXWA>` Handle :rtype: GXWA .. versionadded:: 5.0 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ **Note:** See sbf.gxh. ANSI Encoding is assumed, See `create_sbf_ex <geosoft.gxapi.GXWA.create_sbf_ex>` to override this. """ ret_val = gxapi_cy.WrapWA._create_sbf(GXContext._get_tls_geo(), sbf, file.encode(), append) return GXWA(ret_val)
def load_shape(cls, file, layer_prefix, layer_suffix): """ Load a `GXSHP <geosoft.gxapi.GXSHP>` file to the current data frame :param file: File Name :param layer_prefix: Layer Name Prefix: An underscore is added automatically :param layer_suffix: Layer Name Suffix An underscore is added automatically :type file: str :type layer_prefix: str :type layer_suffix: str .. versionadded:: 8.0 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ **Note:** The input layer name is created using the (optional) prefix and suffix as follows: Prefix_NAME_Suffix """ gxapi_cy.WrapARCMAP._load_shape(GXContext._get_tls_geo(), file.encode(), layer_prefix.encode(), layer_suffix.encode())
def compute_surface_simplification(cls, inputSurfaceFile, inputSurface, outputSurfaceFile, outputSurface): """ Simplifies a surface by reducing the number of edges by half :param inputSurfaceFile: Input Geosurface file :param inputSurface: Input Surface Name within Geosurface File :param outputSurfaceFile: Output Geosurface file :param outputSurface: Output Surface Name within Geosurface File :type inputSurfaceFile: str :type inputSurface: str :type outputSurfaceFile: str :type outputSurface: str .. versionadded:: 9.5 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ """ gxapi_cy.WrapMESHUTIL._compute_surface_simplification( GXContext._get_tls_geo(), inputSurfaceFile.encode(), inputSurface.encode(), outputSurfaceFile.encode(), outputSurface.encode())
def datamine_type(cls, file): """ Returns the type of a Datamine file. :param file: Name of input datamine file :type file: str :returns: Datamine file types - bitwise AND of types. :rtype: int .. versionadded:: 6.3 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ **Note:** Terminates if file is not a Datamine file. A datamine file can contain fields from a multitude of types, so use `GXMATH.and_ <geosoft.gxapi.GXMATH.and_>` or `GXMATH.or_ <geosoft.gxapi.GXMATH.or_>` to determine if the file contains the required data. """ ret_val = gxapi_cy.WrapGIS._datamine_type(GXContext._get_tls_geo(), file.encode()) return ret_val
def sync(cls, mxd): """ Syncronize any Metadata for this `GXMXD <geosoft.gxapi.GXMXD>` :param mxd: `GXMXD <geosoft.gxapi.GXMXD>` file name :type mxd: str .. versionadded:: 7.0 **License:** `Geosoft End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-end-user-lic>`_ """ gxapi_cy.WrapMXD._sync(GXContext._get_tls_geo(), mxd.encode()) ### endblock ClassImplementation ### block ClassExtend # NOTICE: The code generator will not replace the code in this block ### endblock ClassExtend ### block Footer # NOTICE: The code generator will not replace the code in this block ### endblock Footer
def em_layer(cls, coil_spacing, coil_frequency, coil_height, coil_configuration, n_layers, vv_thickness, vv_sigma, in_phase, quadrature): """ Calculate the EM response of a layered earth model. :param coil_spacing: Coil spacing, error if == 0 :param coil_frequency: Coil frequency :param coil_height: Coil height above layer [0] :param coil_configuration: :ref:`EMLAY_GEOMETRY` :param n_layers: Number of layers (including lower halfspace) :param vv_thickness: sNLayer-1 thicknesses [0] to [sNLayer-2] :param vv_sigma: sNLayer conductivities [0] to [sNLayer-1] :param in_phase: On return - in-phase part (ppm) :param quadrature: On return - quadrature part (ppm) :type coil_spacing: float :type coil_frequency: float :type coil_height: float :type coil_configuration: int :type n_layers: int :type vv_thickness: GXVV :type vv_sigma: GXVV :type in_phase: float_ref :type quadrature: float_ref :returns: 0 of OK 1 if some error :rtype: int .. versionadded:: 5.0 **License:** `Geosoft End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-end-user-lic>`_ """ ret_val, in_phase.value, quadrature.value = gxapi_cy.WrapGU._em_layer( GXContext._get_tls_geo(), coil_spacing, coil_frequency, coil_height, coil_configuration, n_layers, vv_thickness, vv_sigma, in_phase.value, quadrature.value) return ret_val
def attach_mdf(cls, server, user, password, db, mdf_file_name, ldf_file_name): """ Attaches an MDF SQL server file to a server. :param server: SQL server to use :param user: User name (if blank assume NT Integrated Security) :param password: Password :param db: `GXDB <geosoft.gxapi.GXDB>` name :param mdf_file_name: MDF name :param ldf_file_name: LDF name (if blank, tries single db attach) :type server: str :type user: str :type password: str :type db: str :type mdf_file_name: str :type ldf_file_name: str :returns: 0 - OK 1 - `GXDB <geosoft.gxapi.GXDB>` Operation Canceled Terminates on Error :rtype: int .. versionadded:: 5.1.8 **License:** `Geosoft End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-end-user-lic>`_ **Note:** The file's path need to be visible as local files on the server. Network drives and substitutes may not work. """ ret_val = gxapi_cy.WrapSQLSRV._attach_mdf(GXContext._get_tls_geo(), server.encode(), user.encode(), password.encode(), db.encode(), mdf_file_name.encode(), ldf_file_name.encode()) return ret_val
def clip_surface_with_grid(cls, inputSurfaceFile, inputSurface, gridSurfaceFileName, gridSurfaceName, outputSurfaceFile, outputSurfaceNameAbove, outputSurfaceNameBelow, surface_clip_mode): """ Clip a Surface with a Grid Surface (grid converted to surface) :param inputSurfaceFile: Input Geosurface file :param inputSurface: Input Surface name within Geosurface file :param gridSurfaceFileName: Grid Surface file name :param gridSurfaceName: Grid surface name within file :param outputSurfaceFile: Output Surface file :param outputSurfaceNameAbove: Name of Surface Item above grid - required for mode=CLIP_ABOVE and CLIP_BOTH :param outputSurfaceNameBelow: Name of Surface Item below grid - required for mode=CLIP_BELOW and CLIP_BOTH :param surface_clip_mode: :ref:`SURFACE_CLIP_MODE` :type inputSurfaceFile: str :type inputSurface: str :type gridSurfaceFileName: str :type gridSurfaceName: str :type outputSurfaceFile: str :type outputSurfaceNameAbove: str :type outputSurfaceNameBelow: str :type surface_clip_mode: int :returns: Surface clip status :rtype: int .. versionadded:: 9.5 **License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_ """ ret_val = gxapi_cy.WrapMESHUTIL._clip_surface_with_grid( GXContext._get_tls_geo(), inputSurfaceFile.encode(), inputSurface.encode(), gridSurfaceFileName.encode(), gridSurfaceName.encode(), outputSurfaceFile.encode(), outputSurfaceNameAbove.encode(), outputSurfaceNameBelow.encode(), surface_clip_mode) return ret_val