def import_grid_to_surface(cls, grid_file_name, geosurface_filename,
surface_name):
"""
Imports a Grid to a Surface
:param grid_file_name: Grid File Name
:param geosurface_filename: Surface File Name
:param surface_name: Surface Item Name within the file
:type grid_file_name: str
:type geosurface_filename: str
:type surface_name: str
.. versionadded:: 9.5
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
"""
gxapi_cy.WrapMESHUTIL._import_grid_to_surface(
GXContext._get_tls_geo(), grid_file_name.encode(),
geosurface_filename.encode(), surface_name.encode())
def scan_daarc500_serial(cls, file, vv_type, vv_items):
"""
Scan Serial data from the RMS Instruments DAARC500.
:param file: File to import
:param vv_type: 8 Recognized types - `GS_LONG <geosoft.gxapi.GS_LONG>`
:param vv_items: 8 Numbers of items - `GS_LONG <geosoft.gxapi.GS_LONG>`
:type file: str
:type vv_type: GXVV
:type vv_items: GXVV
.. versionadded:: 7.2
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
**Note:** Scans the file to see which of the 8 serial channels were used to store data.
"""
gxapi_cy.WrapGU._scan_daarc500_serial(GXContext._get_tls_geo(),
file.encode(), vv_type, vv_items)
def add_document_include_meta(cls, name, type, meta, display):
"""
Adds (and opens) a document file in the current project.
:param name: Document name
:param type: Type of document to add
:param meta: Meta file to load
:param display: :ref:`PROJ_DISPLAY`
:type name: str
:type type: str
:type meta: str
:type display: int
:returns: 0 - Ok
1 - Error
:rtype: int
.. versionadded:: 2022.1
**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:** The passed file name must be a valid
file name complete with an extension and
qualifiers (if applicable).
The type string can be one of the following:
Database
Grid
Map
3DView
Geosurface
Voxel
VoxelInversion
GMS3D
GMS2D
"""
ret_val = gxapi_cy.WrapPROJ._add_document_include_meta(
GXContext._get_tls_geo(), name.encode(), type.encode(),
meta.encode(), display)
return ret_val
def current(cls):
"""
This method returns the Current map opened.
:returns: `GXMAP <geosoft.gxapi.GXMAP>` Object
:rtype: GXMAP
.. 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:** If there is no current map, and running interactively,
the user is prompted to open a map.
"""
ret_val = gxapi_cy.WrapMAP._current(GXContext._get_tls_geo())
return GXMAP(ret_val)
def gr_curv_cor_ex(cls, vv_elev, vv_lat, vv_boug, rho):
"""
Gravity Curvature (Bullard B) Correction to Bouguer anomaly, with user input cap density.
:param vv_elev: Input Elevation `GXVV <geosoft.gxapi.GXVV>`
:param vv_lat: Input Latitude `GXVV <geosoft.gxapi.GXVV>`
:param vv_boug: Bouguer `GXVV <geosoft.gxapi.GXVV>` for Curvature Correction
:param rho: Cap Density (g/cm^3
:type vv_elev: GXVV
:type vv_lat: GXVV
:type vv_boug: GXVV
:type rho: float
.. versionadded:: 8.0.1
**License:** `Geosoft End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-end-user-lic>`_
"""
gxapi_cy.WrapGU._gr_curv_cor_ex(GXContext._get_tls_geo(), vv_elev,
vv_lat, vv_boug, rho)
def load(cls, file):
"""
Load and return handle to a convolution filter.
:param file: Name of the filter File
:type file: 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.
A filter file is an ASCII file that contains filter
coefficients, which are simply mumbers. There can be
one coefficient to a line. Blank lines and comment lines
are skipped. Comment lines beginn with a forward slash
character in column 1. Following is an example Fraser
Filter file:
/----------------------
/ Fraser Filter
/----------------------
-1
-1
1
1
"""
ret_val = gxapi_cy.WrapFLT._load(GXContext._get_tls_geo(),
file.encode())
return ret_val
### 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 create_map(cls, map, name):
"""
Create `GXITR <geosoft.gxapi.GXITR>` from Map with `GXAGG <geosoft.gxapi.GXAGG>` Group name.
:param map: `GXMAP <geosoft.gxapi.GXMAP>` on which to place the view
:param name: `GXAGG <geosoft.gxapi.GXAGG>` Group name
:type map: GXMAP
:type name: str
:returns: `GXITR <geosoft.gxapi.GXITR>` object
:rtype: GXITR
.. versionadded:: 5.0
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
"""
ret_val = gxapi_cy.WrapITR._create_map(GXContext._get_tls_geo(), map,
name.encode())
return GXITR(ret_val)
def current_no_activate(cls):
"""
This method returns the Current Edited map template.
:returns: `GXEMAPTEMPLATE <geosoft.gxapi.GXEMAPTEMPLATE>` Object
:rtype: GXEMAPTEMPLATE
.. 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.GXEMAPTEMPLATE.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.WrapEMAPTEMPLATE._current_no_activate(GXContext._get_tls_geo())
return GXEMAPTEMPLATE(ret_val)
def un_load_verify(cls, name, prompt):
"""
Unloads an edited map, optional prompt to save.
:param name: Name of map to unload
:param prompt: prompt
:type name: str
:type prompt: bool
.. 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:** If the map is not loaded, nothing happens.
If "FALSE", map is saved without a prompt.
"""
gxapi_cy.WrapEMAPTEMPLATE._un_load_verify(GXContext._get_tls_geo(), name.encode(), prompt)
def create(cls, name, mode):
"""
Create a `GXMAP <geosoft.gxapi.GXMAP>`.
:param name: `GXMAP <geosoft.gxapi.GXMAP>` file name
:param mode: :ref:`MAP_OPEN`
:type name: str
:type mode: int
:returns: `GXMAP <geosoft.gxapi.GXMAP>` Object
:rtype: GXMAP
.. versionadded:: 5.0
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
"""
ret_val = gxapi_cy.WrapMAP._create(GXContext._get_tls_geo(),
name.encode(), mode)
return GXMAP(ret_val)
def create_new(cls, file_name, mview):
"""
Create a new `GX3DV <geosoft.gxapi.GX3DV>`.
:param file_name: `GX3DV <geosoft.gxapi.GX3DV>` file name
:param mview: 3D `GXMVIEW <geosoft.gxapi.GXMVIEW>` to create new `GX3DV <geosoft.gxapi.GX3DV>` from
:type file_name: str
:type mview: GXMVIEW
:returns: `GX3DV <geosoft.gxapi.GX3DV>` Object
:rtype: GX3DV
.. versionadded:: 8.0
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
"""
ret_val = gxapi_cy.Wrap3DV._create_new(GXContext._get_tls_geo(),
file_name.encode(), mview)
return GX3DV(ret_val)
def open(cls, geostring_file, mode):
"""
Open a Geostring file
:param geostring_file: Geostring file name
:param mode: :ref:`GEOSTRING_OPEN`
:type geostring_file: str
:type mode: int
:returns: `GXGEOSTRING <geosoft.gxapi.GXGEOSTRING>` Object
:rtype: GXGEOSTRING
.. versionadded:: 8.4
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
"""
ret_val = gxapi_cy.WrapGEOSTRING._open(GXContext._get_tls_geo(),
geostring_file.encode(), mode)
return GXGEOSTRING(ret_val)
def open(cls, surface_file, mode):
"""
Open a Geosurface file
:param surface_file: Geosurface file name
:param mode: :ref:`SURFACE_OPEN`
:type surface_file: str
:type mode: int
:returns: `GXSURFACE <geosoft.gxapi.GXSURFACE>` Object
:rtype: GXSURFACE
.. versionadded:: 8.4
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
"""
ret_val = gxapi_cy.WrapSURFACE._open(GXContext._get_tls_geo(),
surface_file.encode(), mode)
return GXSURFACE(ret_val)
def create(cls, surface_file, ipj):
"""
Create a new Geosurface file
:param surface_file: Geosurface file name
:param ipj: `GXIPJ <geosoft.gxapi.GXIPJ>` containing coordinate system of the Geosurface
:type surface_file: str
:type ipj: GXIPJ
:returns: `GXSURFACE <geosoft.gxapi.GXSURFACE>` Object
:rtype: GXSURFACE
.. versionadded:: 8.4
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
"""
ret_val = gxapi_cy.WrapSURFACE._create(GXContext._get_tls_geo(),
surface_file.encode(), ipj)
return GXSURFACE(ret_val)
def create_ex2(cls, img, elev_unit, dinner, douter, dens_t, dens_w, elev_w,
edge, edge_elev, opt, survey_type, img2):
"""
Creates a Terrain Correction object with surveytype and topo surface elevation grid
:param img: Topo (Rock Surface DEM) grid
:param elev_unit: Elevation unit in 1 metre (i.e. 0.3048 for feet)
:param dinner: Inner distance (in topo grid projection units, default in metres)
:param douter: Outer distance (in topo grid projection units, default in metres)
:param dens_t: Terrain density in g/cc
:param dens_w: Water density in g/cc
:param elev_w: Water reference elevation (in elevation unit)
:param edge: 1 to calculate an edge correction (compensation), 0 otherwise
:param edge_elev: Average elevation beyond max distance (in elevation unit)
:param opt: :ref:`TC_OPT`
:param survey_type: :ref:`TC_SURVEYTYPE`
:param img2: Topo (Elev Surface DEM) grid
:type img: GXIMG
:type elev_unit: float
:type dinner: float
:type douter: float
:type dens_t: float
:type dens_w: float
:type elev_w: float
:type edge: int
:type edge_elev: float
:type opt: int
:type survey_type: int
:type img2: GXIMG
:returns: `GXTC <geosoft.gxapi.GXTC>` Object
:rtype: GXTC
.. versionadded:: 9.9
**License:** `Geosoft Extended End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-ext-end-user-lic>`_
"""
ret_val = gxapi_cy.WrapTC._create_ex2(GXContext._get_tls_geo(), img,
elev_unit, dinner, douter,
dens_t, dens_w, elev_w, edge,
edge_elev, opt, survey_type,
img2)
return GXTC(ret_val)
def open(cls, fileName, lstMeshNames):
"""
Opens an existing Mesh
:param fileName: File Name
:param lstMeshNames: `GXLST <geosoft.gxapi.GXLST>` to fill with Mesh Names
:type fileName: str
:type lstMeshNames: GXLST
:returns: `GXMESH <geosoft.gxapi.GXMESH>` handle, terminates if creation fails
:rtype: GXMESH
.. versionadded:: 9.5
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
"""
ret_val = gxapi_cy.WrapMESH._open(GXContext._get_tls_geo(),
fileName.encode(), lstMeshNames)
return GXMESH(ret_val)
def un_load_discard(cls, name, type):
"""
Unloads a document in the workspace, discards changes.
:param name: Name of document to unload
:param type: :ref:`EDOC_TYPE`
:type name: str
:type type: 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:** If the document is not loaded, nothing happens.
"""
gxapi_cy.WrapEDOC._un_load_discard(GXContext._get_tls_geo(),
name.encode(), type)
def get_block_model_string_variable_values(cls, block_model_file,
variable_name, lst):
"""
Query a block model for the values a string variable can assume.
:param block_model_file: Block model file
:param variable_name: Variable name
:param lst: List used to return variable names
:type block_model_file: str
:type variable_name: str
:type lst: GXLST
.. 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._get_block_model_string_variable_values(
GXContext._get_tls_geo(), block_model_file.encode(),
variable_name.encode(), lst)
def create_arc_lyr_from_tmp(cls, arc_lyr_file):
"""
Create an `GXDATALINKD <geosoft.gxapi.GXDATALINKD>` object from a temporary ArcGIS LYR file
:param arc_lyr_file: Arc LYR file name
:type arc_lyr_file: str
:returns: `GXDATALINKD <geosoft.gxapi.GXDATALINKD>` handle, terminates if creation fails
:rtype: GXDATALINKD
.. versionadded:: 7.0
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
**Note:** Needs ArcEngine licence.
"""
ret_val = gxapi_cy.WrapDATALINKD._create_arc_lyr_from_tmp(
GXContext._get_tls_geo(), arc_lyr_file.encode())
return GXDATALINKD(ret_val)
def create(cls, input, output):
"""
This method creates a projection object.
:param input: Input PRJ file name, "" for geodetic
:param output: Ouput PRJ file name, "" for geodetic
:type input: str
:type output: str
:returns: `GXPJ <geosoft.gxapi.GXPJ>` Object
:rtype: GXPJ
.. versionadded:: 5.0
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
"""
ret_val = gxapi_cy.WrapPJ._create(GXContext._get_tls_geo(),
input.encode(), output.encode())
return GXPJ(ret_val)
def set_agg_map(cls, map, name, itr):
"""
Set `GXITR <geosoft.gxapi.GXITR>` to an `GXAGG <geosoft.gxapi.GXAGG>` in map
:param map: `GXMAP <geosoft.gxapi.GXMAP>` on which to place the view
:param name: `GXAGG <geosoft.gxapi.GXAGG>` group name
:param itr: `GXITR <geosoft.gxapi.GXITR>` object to set
:type map: GXMAP
:type name: str
:type itr: GXITR
.. versionadded:: 5.0
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
**Note:** See the `create_map <geosoft.gxapi.GXITR.create_map>` function
"""
gxapi_cy.WrapITR._set_agg_map(GXContext._get_tls_geo(), map,
name.encode(), itr)
def load_spf(cls, shp, num_shp):
"""
Load all the shape files generated by importing a SPF into ArcMap.
:param shp: List of shape files to load
:param num_shp: Number of shape files
:type shp: str
:type num_shp: int
:returns: 0- OK, 1 - Error, -1 - Cancel
:rtype: int
.. versionadded:: 8.0
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
"""
ret_val = gxapi_cy.WrapARCMAP._load_spf(GXContext._get_tls_geo(),
shp.encode(), num_shp)
return ret_val
def create_xy(cls, db, line_lst):
"""
Create a `GXDBREAD <geosoft.gxapi.GXDBREAD>` object for a XY-located data. Add channels using the
`add_channel <geosoft.gxapi.GXDBREAD.add_channel>` method.
:param db: Database input
:param line_lst: List of lines to process NAME = line name, VALUE = line symbol
:type db: GXDB
:type line_lst: GXLST
:returns: `GXDBREAD <geosoft.gxapi.GXDBREAD>` object
:rtype: GXDBREAD
.. versionadded:: 8.5
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
"""
ret_val = gxapi_cy.WrapDBREAD._create_xy(GXContext._get_tls_geo(), db, line_lst)
return GXDBREAD(ret_val)
def show_layer_by_name_in_3d(cls, mxd_file, dataframe_name, layer_name):
"""
Shows a layer in ArcMap in a 3D view in an `GXMXD <geosoft.gxapi.GXMXD>`
:param mxd_file: `GXMXD <geosoft.gxapi.GXMXD>` filename
:param dataframe_name: Dataframe name
:param layer_name: Layer name
:type mxd_file: str
:type dataframe_name: str
:type layer_name: str
.. versionadded:: 8.0
**License:** `Geosoft Extended End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-ext-end-user-lic>`_
"""
gxapi_cy.WrapARCMAP._show_layer_by_name_in_3d(GXContext._get_tls_geo(),
mxd_file.encode(),
dataframe_name.encode(),
layer_name.encode())
def gr_demvv(cls, im_gdem, vv_x, vv_y, vv_z):
"""
Get gravity DEM grid `GXVV <geosoft.gxapi.GXVV>` for Bouguer anomaly
:param im_gdem: DEM grid
:param vv_x: Input X `GXVV <geosoft.gxapi.GXVV>`
:param vv_y: Input Y `GXVV <geosoft.gxapi.GXVV>`
:param vv_z: Output DEM `GXVV <geosoft.gxapi.GXVV>` for Bouguer Correction
:type im_gdem: GXIMG
:type vv_x: GXVV
:type vv_y: GXVV
:type vv_z: GXVV
.. versionadded:: 6.2
**License:** `Geosoft End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-end-user-lic>`_
"""
gxapi_cy.WrapGU._gr_demvv(GXContext._get_tls_geo(), im_gdem, vv_x,
vv_y, vv_z)
def create(cls, name):
"""
This method creates a Dialog window from a specified
resource. The Resource is loaded into memory but not displayed.
:param name: Name of the Window Resource to use
:type name: str
:returns: Handle to the `GXDGW <geosoft.gxapi.GXDGW>` object.
:rtype: GXDGW
.. 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.
"""
ret_val = gxapi_cy.WrapDGW._create(GXContext._get_tls_geo(), name.encode())
return GXDGW(ret_val)
def create(cls):
"""
Create a handle to a Rangrid object
:returns: `GXRGRD <geosoft.gxapi.GXRGRD>` Object
:rtype: GXRGRD
.. versionadded:: 5.0
**License:** `Geosoft Extended End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-ext-end-user-lic>`_
**Note:** The Rangrid object is initially empty. It will store the
control file parameters which the Rangrid program needs
to execute. Use the LoadParms_RGRD method to get the
control file parameters into the `GXRGRD <geosoft.gxapi.GXRGRD>` object.
"""
ret_val = gxapi_cy.WrapRGRD._create(GXContext._get_tls_geo())
return GXRGRD(ret_val)
def td_xd_y(cls, img_tx, img_ty, out_fil, inv_flg):
"""
`GXFFT2 <geosoft.gxapi.GXFFT2>` filter (calculate T from the derivatives Tx and Ty)
:param img_tx: Input dX image (Transform grid)
:param img_ty: Input dY image (Transform grid)
:param out_fil: Output T file name
:param inv_flg: 0 - no invers, 1 - invers `GXFFT <geosoft.gxapi.GXFFT>` applied
:type img_tx: GXIMG
:type img_ty: GXIMG
:type out_fil: str
:type inv_flg: int
.. versionadded:: 5.0.1
**License:** `Geosoft Extended End-User License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-ext-end-user-lic>`_
"""
gxapi_cy.WrapFFT2._td_xd_y(GXContext._get_tls_geo(), img_tx, img_ty,
out_fil.encode(), inv_flg)
def create_xgd(cls, name, mode):
"""
Create a handle to a grid file `GXDAT <geosoft.gxapi.GXDAT>` object
:param name: Name of grid file to associate `GXDAT <geosoft.gxapi.GXDAT>` with
:param mode: :ref:`DAT_XGD`
:type name: str
:type mode: int
: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_xgd(GXContext._get_tls_geo(),
name.encode(), mode)
return GXDAT(ret_val)
def h_create_img(cls, img, name):
"""
Make an `GXHGD <geosoft.gxapi.GXHGD>` from an `GXIMG <geosoft.gxapi.GXIMG>`
:param img: Image Handle
:param name: Name of `GXHGD <geosoft.gxapi.GXHGD>` object
:type img: GXIMG
:type name: str
:returns: `GXHGD <geosoft.gxapi.GXHGD>` Object
:rtype: GXHGD
.. versionadded:: 5.1
**License:** `Geosoft Open License <https://geosoftgxdev.atlassian.net/wiki/spaces/GD/pages/2359406/License#License-open-lic>`_
"""
ret_val = gxapi_cy.WrapHGD._h_create_img(GXContext._get_tls_geo(), img,
name.encode())
return GXHGD(ret_val)
