Source code for GM

#
# Custom GlobalMapper module (EXAMPLE)
#

import globalmapper as gm



[docs]class Point_t(gm.GM_Point_t): """This describes a single point location Parameters __________ mX: float X (or longitude) coordinate mY: float Y (or latitude) coordinate """ def __init__(self, mX: float, mY: float): super().__init__() # Fields self.mX = mX self.mY = mY
[docs]class LidarReturnInfo_t(gm.GM_LidarReturnInfo_t): """Statistics about different Lidar point types. This can be used for statistics for a single class or return type Parameters __________ mCount: int Number of points encountered of this type mMinZ: int Minimum Z value mMaxZ: int Maximum Z value mMinI: int Minimum Intensity value mMaxI: int Maximum Intensity value mSyntheticCount: int Synthetic count mWithheldCount: int Withheld count mKeyPointCount: int Model key count mOverlapCount: int Overlap point count """ def __init__(self, mCount: int = 0, mMinZ: int = 0, mMaxZ: int = 0, mMinI: int = 0, mMaxI: int = 0, mSyntheticCount: int = 0, mWithheldCount: int = 0, mKeyPointCount: int = 0, mOverlapCount: int = 0): super().__init__() self.mCount = mCount self.mMinZ = mMinZ self.mMaxZ = mMaxZ self.mMinI = mMinI self.mMaxI = mMaxI self.mSyntheticCount = mSyntheticCount self.mWithheldCount = mWithheldCount self.mKeyPointCount = mKeyPointCount self.mOverlapCount = mOverlapCount
[docs]class LidarAttrInfo_t(gm.GM_LidarAttrInfo_t): """Definition of statistics for each Lidar attribute LidarAttrInfo_t(mMinVal: int=0, mMaxVal: int=0) Parameters __________ mMinVal: int Minimum encountered value mMaxVal: int Maximum encountered value """ def __init__(self, mMinVal: int = 0, mMaxVal: int = 0): super().__init__() self.mMinVal = mMinVal self.mMaxVal = mMaxVal
[docs]class LidarPoint_t(gm.GM_LidarPoint_t): """This type is used to return information about Lidar point cloud features LidarPoint_t(mLayer: int = 0, mPointIdx: int = 0, mFlags: int = 0, mPos= Point_t(0, 0), mElevMeters: float = 0, mIntensity: int = 0, mClass=gm.GM_LidarClass_Unclassified, mRetNum: int = 0, mRetCount: int = 0, mUserData: int = 0, mScannerChannel: int = 0, mScanAngle: int = 0, mGpsTime: float = 0.0, mSourceId: int = 0, mRed: int = 0, mGreen: int = 0, mBlue: int = 0, mNIR: int = 0) Parameters ___________ mLayer: int Layer the point is from mPointIdx: int Point index in cloud mFlags: int Flags about the point mPos: Point_t Location of the point (global coordinates when getting, native when adding feature) mElevMeters: float Elevation of point in meters mIntensity: int Intensity mClass: GM_LidarClass_t8, int Classification mRetNum: int Return number mRetCount: int Number of returns mUserData: int User data mScannerChannel: int Scanner channel mScanAngle: float Scan Angle mGpsTime: double (float) GPS time mSourceId: int Point Source ID mRed: int Red color value mGreen: int Green color value mBlue: int Blue color value mNIR: int NIR (near infrared) value """ def __init__(self, mLayer: int=0, mPointIdx: int=0, mFlags: int=0, mPos=Point_t(0, 0), mElevMeters: float=0, mIntensity: int=0, mClass=gm.GM_LidarClass_Unclassified, mRetNum: int=0, mRetCount: int=0, mUserData: int = 0, mScannerChannel: int=0, mScanAngle: int=0, mGpsTime: float = 0.0, mSourceId: int = 0, mRed: int = 0, mGreen: int = 0, mBlue: int = 0, mNIR: int = 0): super().__init__() self.mLayer = mLayer self.mPointIdx = mPointIdx self.mFlags = mFlags self.mPos = mPos self.mElevMeters = mElevMeters self.mIntensity = mIntensity self.mClass = mClass self.mRetNum = mRetNum self.mRetCount = mRetCount self.mUserData = mUserData self.mScannerChannel = mScannerChannel self.mScanAngle = mScanAngle self.mGpsTime = mGpsTime self.mSourceId = mSourceId self.mRed = mRed self.mGreen = mGreen self.mBlue = mBlue self.mNIR = mNIR
[docs]class ElevColor_t(gm.GM_ElevColor_t): """This type represents a single elevation/color pair for a custom shader ElevColor_t(mElev: float=5, mColor: int=0xFFFFFFFF) Parameters ___________ mElev: float, default 5 Elevation value in meters mColor: COLORREF, int, default 0xFFFFFFFF Color value """ #TODO methods def __init__(self, mElev: float = 5, mColor: int = 0xFFFFFFFF): super().__init__() self.mElev = mElev self.mColor = mColor
[docs]class AttrValue_t(gm.GM_AttrValue_t): """This type is used to represent a single attribute value pair AttrValue_t(mName:str , mVal: str) Parameters ___________ mName: string Name of the attribute mVal: string Value of the attribute """ def __init__(self, mName: str, mVal: str): super().__init__() # Fields self.mName = str(mName) self.mVal = str(mVal)
[docs]class OnlineSourceInfo_t(gm.GM_OnlineSourceInfo_t): """This type is used to return information about available online sources OnlineSourceInfo_t( mAttrList: gm.GM_AttrValue_array = gm.GM_AttrValue_array(0), mAttrListSize: int = 0, \ mType: int = gm.GM_SourceType_WMS, mName: str = 'Default Online name')) Parameters ___________ mName: str Name of the online source. This can be passed to LoadOnlineLayer mType: GM_OnlineSourceType_t, int, default=gm.GM_SourceType_WMS Source type mAttrList: AttrValue_array List of additional attributes and values for the source mAttrListSize: int, uint32 Number of entries in mAttrList """ def __init__(self, mName: str = 'Default Online name', mType: int = gm.GM_SourceType_WMS, mAttrList: gm.GM_AttrValue_array = gm.GM_AttrValue_array(1), mAttrListSize: int = 0): super().__init__() # Fields self.mAttrList = mAttrList # when setting, use "obj.mAttrList = array_var.cast()". Without calling .cast(), it may not always work self.mAttrListSize = mAttrListSize self.mName = mName self.mType = mType
# has methods
[docs]class CustomShader_t(gm.GM_CustomShader_t): """This type represents a custom elevation shader CustomShader_t(mShaderName: str = None, mFlags: int = gm.GM_CustomShader_DontBlend,mNumElevs: int = 1, mElevColorList: gm.GM_ElevColor_array = gm.GM_ElevColor_array(1)) Parameters ____________ mShaderName: str Name to use for the shader, default=None mFlags: GM_CustomShaderFlags_t32, int, default=gm.GM_CustomShader_DontBlend Shader flags mNumElevs: int, uint32, default=1 Number of elements in the argument mElevColorList mElevColorList: ElevColor_array List of elevation/color pairs for shader """ def __init__(self, mShaderName: str = None, mFlags: int = gm.GM_CustomShader_DontBlend, mNumElevs: int = 1, mElevColorList: gm.GM_ElevColor_array = gm.GM_ElevColor_array(1)): super().__init__() # Fields self.mShaderName = mShaderName self.mFlags = mFlags self.mElevColorList = mElevColorList # when setting, use "obj.mElevColorList = array_var.cast()". Without calling .cast(), it may not always work self.mNumElevs = mNumElevs
[docs]class GroundControlPoint_t(gm.GM_GroundControlPoint_t): """This type is used when rectifying imagery GroundControlPoint_t(mPixelX: float = 0, mPixelY: float = 0, mGroundX: float = 0, mGroundY: float = 0) Parameters __________ mPixelX: float X pixel coordinate of GCP mPixelY: float Y pixel coordinate of GCP (top is 0, increases down) mGroundX: float X ground coordinate of GCP (in provided projection) mGroundY: float Y ground coordinate of GCP (in provided projection) """ def __init__(self, mPixelX: float = 0, mPixelY: float = 0, mGroundX: float = 0, mGroundY: float = 0): super().__init__(mPixelX, mPixelY, mGroundX, mGroundY)
# class for dtype parameter of array()
[docs]class uint8(int): """Unsigned character type definition. 0 to 255. """ def __new__(cls, val): if val > 255: raise OverflowError('Max size for type uint8 is 255') elif val < 0: raise OverflowError('Min size for type uint8 is 0') return int.__new__(cls, val)
# class for dtype parameter of array()
[docs]class uint32(int): """Unsigned long integer type definition. 0 to 4294967295. """ def __new__(cls, val): if val > 4294967295: raise OverflowError('Max size for type uint32 is 4294967295') elif val < 0: raise OverflowError('Min size for type uint32 is 0') return int.__new__(cls, val)
# class for dtype parameter of array()
[docs]class LayerHandle_t(int): """This type is used to reference a single layer loaded by the DLL. """ def __new__(cls, val): return int.__new__(cls, val)
# class for dtype parameter of array()
[docs]class COLORREF(int): """This type is used to represent a single color palette entry """ def __new__(cls, val): return int.__new__(cls, val)
# A factory method pattern for array construction
[docs]def array(*args, **kwargs): """Factory method function for creating globalmapper.py arrays """ dtype = None size = -1 elements = [] # extract variables from kwargs for key, value in kwargs.items(): if key == "dtype": dtype = value elif key == "size": size = value else: raise TypeError("Invalid key. Must be 'dtype' or 'size'") # check *args if both keys are not set if len(args) < 1: if (size==-1 or dtype==None): raise TypeError("array() missing required argument 'list/tuple/int' (pos 0)") else: # get elements / size if isinstance(args[0], list) or isinstance(args[0], tuple): elements = list(args[0]) if size == -1: size = len(elements) elif isinstance(args[0], int): # give priority to size key, notify user to prevent confusion if size == -1: size = args[0] else: raise TypeError("Key 'size' will take priority for setting the size of the array over args[0]") else: raise TypeError("*args must be of type 'list', 'tuple', or 'int'") # set dtype if null if dtype is None: if len(elements) > 0: dtype = elements[0].__class__ else: # if dtype was not set by key and elements is empty, value error raise TypeError("Either a 'dtype' key must be passed or elements provided") check = dtype #print(f"{check=} vs {type(elements[0])}, {check==gm.GM_AttrValue_t}") # also generalize for the basic types if dtype == uint8 or dtype == uint32 or dtype == LayerHandle_t or dtype == COLORREF: check = int # check type for e in elements: if not isinstance(e, check): raise TypeError("Unexpected type in passed elements") arr = 0 # variable for storing the array if dtype == Point_t or dtype == gm.GM_Point_t: arr = gm.GM_Point_t_array(size) elif dtype == uint8: arr = gm.uint8_array(size) elif dtype == uint32: arr = gm.uint32_array(size) elif dtype == LayerHandle_t: arr = gm.GM_LayerHandle_array(size) elif dtype == GroundControlPoint_t or dtype == gm.GM_GroundControlPoint_t: arr = gm.GM_GroundControlPoint_array(size) elif dtype == AttrValue_t or dtype == gm.GM_AttrValue_t: arr = gm.GM_AttrValue_array(size) elif dtype == gm.GM_PaletteEntry_t: arr = gm.GM_PaletteEntry_array(size) elif dtype == CustomShader_t or dtype == gm.GM_CustomShader_t: arr = gm.GM_CustomShader_array(size) elif dtype == OnlineSourceInfo_t or dtype == gm.GM_OnlineSourceInfo_t: arr = gm.GM_OnlineSourceInfo_array(size) elif dtype == ElevColor_t or dtype == gm.GM_ElevColor_t: arr = gm.GM_ElevColor_array(size) elif dtype == COLORREF: arr = gm.COLORREF_array(size) elif dtype == LidarPoint_t or dtype == gm.GM_LidarPoint_t: arr = gm.GM_LidarPoint_array(size) elif dtype == float: arr = gm.float_array(size) elif dtype == LidarAttrInfo_t or dtype == gm.GM_LidarAttrInfo_t: arr = gm.GM_LidarAttrInfo_array(size) elif dtype == LidarReturnInfo_t or dtype == gm.GM_LidarReturnInfo_t: arr = gm.GM_LidarReturnInfo_array(size) elif dtype == AreaFeature_t or dtype == gm.GM_AreaFeature_t: arr = gm.GM_AreaFeature_array(size) elif dtype == ValName_t or dtype == gm.GM_ValName_t: arr = gm.GM_ValName_array(size) elif dtype == gm.GM_FoundFeature_t: arr = gm.GM_FoundFeature_array(size) #elif dtype == int: # results in inconsistent interpretation when passed to class member variables # arr = gm.uint32_array(size) # if it is a general int type, return a uint32 which will be interpreted as whatever that type was # arr = arr.cast() else: raise TypeError("No GM array class found for dtype/type of first element in elements") # populate the array if elements were passed if len(elements) > 0: for i in range(size): # pad even if passed elements if i < len(elements): arr[i] = elements[i] return arr
[docs]class array_range(): """Class for globalmapper.py array iteration array_range(array, size) Parameters __________ array: globalmapper.xx_array The array to iterate size: int The size of the array """ def __init__(self, array, size): self.array = array self.size = size def __iter__(self): self.iteration = 0 return self def __next__(self): if self.iteration < self.size: result = self.array[self.iteration] self.iteration += 1 return result else: raise StopIteration def __len__(self): return self.size
[docs]class AreaElevStats_t(gm.GM_AreaElevStats_t): """This type is used for returning the calculated elevation statistics within an area AreaElevStats_t(mSize: int, mNumSamples: int, mAvgElev: float, mMinElev: float, mMaxElev: float, mStdDevElev: float, mModeElev: float, mAvgSlope: float, mMaxSlope: float, mStdDevSlope: float, mNumIgnoredSamples: int = 0) Parameters ____________ mSize: int (uint32) Size of the structure mNumSamples: uint64, int Number of locations sampled to compute statistics mAvgElev: float Average elevation in meters mMinElev: float Minimum elevation in meters mMaxElev: float Maximum elevvation in meters mStdDevElev: float Standard deviation of elevation in meters mModeElev: float approximate mode value of elevation in meters mAvgSlope: float Average slope in degrees mMaxSlope: float Maximum slope in degrees mStdDevSlope: float Standard deviation of slope in degrees mNumIgnoredSamples: uint64, int Number of samples that were ignored due to being outside the crop areas or having no elevation\n """ def __init__(self, mSize: int, mNumSamples: int, mAvgElev: float, mMinElev: float, mMaxElev: float, mStdDevElev: float, mModeElev: float, mAvgSlope: float, mMaxSlope: float, mStdDevSlope: float, mNumIgnoredSamples: int = 0): super().__init__() # Fields self.mSize = mSize self.mNumSamples = mNumSamples self.mAvgElev = mAvgElev self.mMinElev = mMinElev self.mMaxElev = mMaxElev self.mStdDevElev = mStdDevElev self.mModeElev = mModeElev self.mAvgSlope = mAvgSlope self.mMaxSlope = mMaxSlope self.mStdDevSlope = mStdDevSlope self.mNumIgnoredSamples = mNumIgnoredSamples
[docs]class FontDef_t(gm.GM_FontDef_t): """This type is used to describe a font used for rendering text FontDef_t(mFaceName: str = 'System', mColor: int = 0, mWeight: int = 10, mPointSize: int = 0, mItalicize: bool = False, mUnderline: bool = False, mStrikeout: bool = False, mCharset: int = 255, mBgMode: int = gm.GM_Font_BgOpaque, mFixedHgt: float = 0.0, mPlacement: int = gm.GM_LABEL_AUTO, mHalo: bool = True, mReserved2: int = 0, mReserved3: int = 0, mAngle: float = 0) Parameters ___________ mFaceName: str, default='System' Name of font face used mColor: COLORREF RGB color of font mWeight: int (uint16) Weight of font (use GM_Constants, like FW_BOLD, FW_THIN, FW_NORMAL, etc.) mPointSize: int (uint8) Font point size (set mFixedHgt value to non-zero to use fixed height) mItalicize: bool Draw text with italics? mUnderline: bool Underline text? mStrikeout: bool Strikeout text? mCharset: int Character set (use OEM_CHARSET (255) for default behavior) mBgMode: GM_FontBackground_t8 Background fill mode (i.e. opaque or transparent) mFixedHgt: float Fixed height of font in meters (use 0.0 for normal point-size font) mPlacement: GM_LabelPlacement_t8 Label placement relative to point features (only applies for point features) mHalo: bool Draw thin halo around text to make it visible on any background. mReserved2: int (uint8) Reserved, must be 0 mReserved2: int (uint8) Reserved, must be 0 mAngle: float Counter-clockwise rotation angle of angle (0 is horizontal left to right) """ # TODO: Methods def __init__(self, mFaceName: str = 'System', mColor: int = 0, mWeight: int = 10, mPointSize: int = 0, mItalicize: bool = False, mUnderline: bool = False, mStrikeout: bool = False, mCharset: int = 255, mBgMode: int = gm.GM_Font_BgOpaque, mFixedHgt: float = 0.0, mPlacement: int = gm.GM_LABEL_AUTO, mHalo: bool = True, mReserved2: int = 0, mReserved3: int = 0, mAngle: float = 0): super().__init__() self.mFaceName = mFaceName self.mColor = mColor self.mWeight = mWeight self.mPointSize = mPointSize self.mItalicize = mItalicize self.mUnderline = mUnderline self.mStrikeout = mStrikeout self.mCharset = mCharset self.mBgMode = mBgMode self.mFixedHgt = mFixedHgt self.mPlacement = mPlacement self.mHalo = mHalo self.mReserved2 = mReserved2 self.mReserved3 = mReserved3 self.mAngle = mAngle
[docs]class SpatialOps_Params_t(gm.GM_SpatialOps_Params_t): """Structure defining parameters for spatial operations and spatial predicates SpatialOps_Params_t(mLogCallback, mFeatureTypes1: int=0, mFeatureTypes2: int=0, mPredicateResultTarget: int=0, mResultLayerName: str="", mResultLayer: int=0, mResultFeatureTypes: int=0, mResultLayerIsTemp: bool=False, mErrorHandling: int=0, mAttemptRepair: bool=True) Parameters ___________ mFeatureTypes1: GM_FeatureFilters_t8, int Feature types for layer 1 mFeatureTypes2: GM_FeatureFilters_t8, int Feature types for layer 2 mPredicateResultTarget: GM_PredicateResultTargets_t8 (int) Where to store the results of the predicate mResultLayerName: str Name of result layer mResultLayer: GM_LayerHandle_t32 (int) Layer to add geometries to mResultFeatureTypes: GM_FeatureFilters_t8 (int) Desired feature class type(s) for results mResultLayerIsTemp: bool If true, result layer should not appear in the Control Panel mErrorHandling: GM_SpatialOps_Errorhandling_t8 (int) Error handling behavior for inputs to the operation mAttemptRepair: bool Attempt repair on invalid input geometries mLogCallback: GM_MessageCallbackFunc Callback for displaying error and warning messages. """ # note: mLogCallback is out of order in __init__ because no reasonable default can be set and it must therefore be positional def __init__(self, mLogCallback, mFeatureTypes1: int=0, mFeatureTypes2: int=0, mPredicateResultTarget: int=0, mResultLayerName: str="", mResultLayer: int=0, mResultFeatureTypes: int=0, mResultLayerIsTemp: bool=False, mErrorHandling: int=0, mAttemptRepair: bool=True): super().__init__() self.mFeatureTypes1 = mFeatureTypes1 self.mFeatureTypes2 = mFeatureTypes2 self.mPredicateResultTarget = mPredicateResultTarget self.mResultLayerName = mResultLayerName self.mResultLayer = mResultLayer self.mResultFeatureTypes = mResultFeatureTypes self.mResultLayerIsTemp = mResultLayerIsTemp self.mErrorHandling = mErrorHandling self.mAttemptRepair = mAttemptRepair self.mLogCallback = mLogCallback
[docs]class AreaStyle_t(gm.GM_AreaStyle_t): """This type is used to describe a style used for drawing an area feature and its label (if any) AreaStyle_t(mBorderPenStyle=gm.GM_PEN_SOLID, mBorderPenWidth: int = 1, mBorderPenColor: int = 0, mBrushColor: int = 0, mBrushStyle=gm.GM_BRUSH_SOLID, mDrawLabel: bool = False, mDrawLabelAlways: bool = False, mFont: FontDef_t = FontDef_t()) Parameters _____________ mBorderPenColor: COLORREF (int) color to use for border pen mBorderPenStyle: PenStyle_t16 Border pen style (i.e. solid, dash, etc.) mBorderPenWidth: Unsigned integer Width to draw border pen in mBrushColor: COLORREF (int) color of brush to fill area with (when applicable to brush style). The color is defined as ARGB where the upper 8 bits are alpha. The exception is a value of 0 in the A is treated as no alpha. mBrushStyle:BrushStyle_t16 Enumeration Style of brush to fill area with mDrawLabel: boolean Render the label for this line if there is one mDrawLabelAlways: boolean Render the label for this line even if it collides with another display label mFont:FontDef_t Font to use to render label """ # TODO It appears GM.AreaStyle_t().mBorderPenColor points to a memory address that has the color def __init__(self, mBorderPenStyle=gm.GM_PEN_SOLID, mBorderPenWidth: int = 1, mBorderPenColor: int = 0, mBrushColor: int = 0, mBrushStyle=gm.GM_BRUSH_SOLID, mDrawLabel: bool = False, mDrawLabelAlways: bool = False, mFont: FontDef_t = FontDef_t()): super().__init__() # Fields self.mBorderPenStyle = mBorderPenStyle self.mBorderPenWidth = mBorderPenWidth self.mBorderPenColor = mBorderPenColor self.mBrushColor = mBrushColor self.mBrushStyle = mBrushStyle self.mDrawLabel = mDrawLabel self.mDrawLabelAlways = mDrawLabelAlways self.mFont = mFont
[docs]class VectorFeature_t(gm.GM_VectorFeature_t): """This type is used as the base for any vector feature information VectorFeature_t(mAttrList: gm.GM_AttrValue_array = array( [AttrValue_t('Name1', 'Val1'), AttrValue_t('Name2', 'Val2')]), mNumAttrs: int = 2, mClass: int = 16, mDesc: str = None, mName: str = None) Parameters __________ mAttrList: gm.AttrValue_array List of attributes associated with feature mNumAttrs: int (uint16) Number of elements in mAttrList mClass: FeatureClass_t16 Global Mapper classification assigned to the feature mDesc: str Description of the feature mName: str Name of the feature """ def __init__(self, mName: str = None, mDesc: str = None, mClass: int = 0, mAttrList: gm.GM_AttrValue_array = array([AttrValue_t('Name1', 'Val1'), AttrValue_t('Name2', 'Val2')]), mNumAttrs: int = 2): super().__init__() # Fields self.mAttrList = mAttrList self.mClass = mClass self.mDesc = mDesc self.mName = mName self.mNumAttrs = mNumAttrs
[docs]class HoleInArea_t(gm.GM_HoleInArea_t): """This type is used to store information about holes within area features HoleInArea_t(mPoints: Point_t_array, mNumPoints: int, mVertexElevList: float_array) Parameters ____________ mPoints: Point_t_array List of points in the hole in global coordinates (pointer to GM_Point_t array) mNumPoints: int Number of points in the list. Automatically set when the point list is updated mVertexElevList: float_array Optional list of elevations for each point in line. If present, must have *mNumPoints* values """ def __init__(self, mPoints: gm.GM_Point_t_array, mNumPoints: int, mVertexElevList: gm.float_array = None): super().__init__() # Properties self.mPoints = mPoints self.mNumPoints = mNumPoints self.mVertexElevList = mVertexElevList # when setting, use "obj.mVertexElevList = array_var.cast()". Without calling .cast(), it may not always work
[docs]class AreaFeature_t(gm.GM_AreaFeature_t): """ AreaFeature_t(mFeatureInfo: VectorFeature_t = VectorFeature_t(), mPointList: gm.GM_Point_t_array = array([Point_t(0, 0), Point_t(0, 1)]), mNumPoints: int=2, mHoleList: HoleInArea_t = HoleInArea_t(array([Point_t(0, 0), Point_t(0, 1)]), 2),mNumHoles: int = 1, mAreaStyle: AreaStyle_t = AreaStyle_t(), mVertexElevList: float = None) Parameters __________ mFeatureInfo: VectorFeature_t The General Vector Feature Info mPointList: Point_t List of points that make up the area (global coordinates when getting, native when adding feature) mNumPoints: int, uint32 Number of points in the list mHoleList: HoleInArea_t List of holes in the area mNumHoles: int, uint32 Number of holes in the list of holes mAreaStyle: AreaStyle_t Area render style (symbol and font) mVertexElevList: float Optional list of elevations for each point in area. If present, must be same size as mPointsList """ # TODO Methods #TODO mHoleList is an array of type HoleInArea_t, which is not implemented yet def __init__(self, mFeatureInfo: VectorFeature_t = VectorFeature_t(), mPointList: gm.GM_Point_t_array = array([Point_t(0, 0), Point_t(0, 1)]), mNumPoints: int=2, mHoleList: HoleInArea_t = HoleInArea_t(array([Point_t(0, 0), Point_t(0, 1)]), 2),mNumHoles: int = 1, mAreaStyle: AreaStyle_t = AreaStyle_t(), mVertexElevList: float = None): super().__init__() # Fields self.mFeatureInfo = mFeatureInfo # VectorFeature_t type self.mPointList = mPointList self.mNumPoints = mNumPoints self.mVertexElevList = mVertexElevList # when setting, use "obj.mVertexElevList = array_var.cast()". Without calling .cast(), it may not always work self.mHoleList = mHoleList self.mNumHoles = mNumHoles self.mAreaStyle = mAreaStyle
[docs]class AreaVolumeParams_t(gm.GM_AreaVolumeParams_t): """This type is used to provide the parameters for calculating cut-and-fill volumes within an area feature AreaVolumeParams_t(mSize = 0, mPoints: gm.GM_Point_t_array = array([Point_t(0, 0), Point_t(0, 1)]), mNumPoints: int = 2, mCutHeight: float = 0.0, mXSpacing: float = 0.0, mYSpacing: float = 0.0, mFillGaps: bool = True) Parameters ____________ mSize: int, uint32 Size of structure mPoints: Point_t List of points in area in global coordinate system mNumPoints: int, uint32 Number of points in the argument mPoints mCutHeight: float Cut height in meters above sea level mXSpacing: float Sample spacing in the x direction in global units mYSpacing: float Sample spacing in the y direction in global units mFillGaps: boolean Fill gaps in terrain from surrounding data """ def __init__(self, mSize = 0, mPoints: gm.GM_Point_t_array = array([Point_t(0, 0), Point_t(0, 1)]), mNumPoints: int = 2, mCutHeight: float = 0.0, mXSpacing: float = 0.0, mYSpacing: float = 0.0, mFillGaps: bool = True): super().__init__() # Fields self.mSize = mSize self.mPoints = mPoints self.mNumPoints = mNumPoints self.mCutHeight = mCutHeight self.mXSpacing = mXSpacing self.mYSpacing = mYSpacing self.mFillGaps = mFillGaps
[docs]class AsciiFormatInfo_t(gm.GM_AsciiFormatInfo_t): """This type represents layout information for a generic ASCII import AsciiFormatInfo_t(mImportType=gm.GM_AsciiImport_Vector, mCoordDelim=gm.GM_AsciiDelim_AutoDetect, mCoordOrder=gm.GM_AsciiCoordOrder_XFirst, mIncludeCoordAttrs: bool = False, mColumnHeadersInFirstRow: bool = True, mIncludeElevCoords: bool = False, mColumnsToSkip: int = 0, mLinesToSkip: int = 0, mCoordLinePrefix: str = None, mAreaType=gm.AFC_UNKNOWN, mLineType=gm.LFC_MIN_LINE, mPointType=gm.PFC_MIN_POINT, mIgnoreZeroElevations: bool = True, mFillToBounds: bool = False, mOffsetX: float = 0.0, mOffsetY: float = 0.0, mOffsetZ: float = 0.0, mScaleX: float = 1.0, mScaleY: float = 1.0, mScaleZ: float = 1.0, mNoDataDistanceFactor: float = 0.0, mBreakOnColumnIdx: gm.uint8_array = gm.uint8_array(2),mCoordFormat=gm.GM_AsciiCoordFormat_Decimal,): Parameters ___________ mImportType: GM_AsciiImportType_t8 Specify import type mCoordDelim: GM_AsciiCoordDelim_t8 Specify coordinate delimiter mCoordOrder: GM_AsciiCoordOrder_t8 Coordinate order mIncludeCoordAttrs: boolean attributes from coordinate lines mColumnHeadersInFirstRow: boolean Is the first row of the file column headers? (like for CSV files) mIncludeElevCoords: boolean Is the 3rd coordinate column an elevation or Z value? Must be TRUE for eAsciiImportElevation import type. mColumnsToSkip: int, uint8 Columns to skip before reaching coordinate columns mLinesToSkip: int, uint8 Number of lines to skip mCoordLinePrefix: string Prefix to look for at beginning of coordinate lines (default to NULL or empty) mAreaType: AreaFeatureClass_t16 Area type to assign to imported created area features mLineType: LineFeatureClass_t16 Line type to assign to imported created line features mPointType: PointFeatureClass_t16 Point type to assign to imported point features mIgnoreZeroElevations: boolean Ignore features with an elevation of zero mFillToBounds: boolean Fill grid to full bounds of data (i.e. don't constrict to convex hull) mOffsetX: float Offset to apply to X coordinates mOffsetY: float Offset to apply to Y coordinates mOffsetZ: float Offset to apply to Z coordinates mScaleX: float Scale to apply to X coordinates (default is 1.0) mScaleY: float Scale to apply to Y coordinates (default is 1.0) mScaleZ: float Scale to apply to Z coordinates (default is 1.0) mNoDataDistanceFactor: float Tightness factor to use when gridding 3D data. Use 0.0 for default. mBreakOnColumnIdx: int, uint8 Index of column to break features on when value changes. Pass NULL for default break behavior. mCoordFormat: GM_AsciiCoordFormat_t8 Coordinate format """ def __init__(self, mImportType=gm.GM_AsciiImport_Vector, mCoordDelim=gm.GM_AsciiDelim_AutoDetect, mCoordOrder=gm.GM_AsciiCoordOrder_XFirst, mIncludeCoordAttrs: bool = False, mColumnHeadersInFirstRow: bool = True, mIncludeElevCoords: bool = False, mColumnsToSkip: int = 0, mLinesToSkip: int = 0, mCoordLinePrefix: str = None, mAreaType=gm.AFC_UNKNOWN, mLineType=gm.LFC_MIN_LINE, mPointType=gm.PFC_MIN_POINT, mIgnoreZeroElevations: bool = True, mFillToBounds: bool = False, mOffsetX: float = 0.0, mOffsetY: float = 0.0, mOffsetZ: float = 0.0, mScaleX: float = 1.0, mScaleY: float = 1.0, mScaleZ: float = 1.0, mNoDataDistanceFactor: float = 0.0, mBreakOnColumnIdx: gm.uint8_array = None, mCoordFormat=gm.GM_AsciiCoordFormat_Decimal,): super().__init__() self.mImportType = mImportType self.mCoordDelim = mCoordDelim self.mCoordOrder = mCoordOrder self.mIncludeCoordAttrs = mIncludeCoordAttrs self.mColumnHeadersInFirstRow = mColumnHeadersInFirstRow self.mIncludeElevCoords = mIncludeElevCoords self.mColumnsToSkip = mColumnsToSkip self.mLinesToSkip = mLinesToSkip self.mCoordLinePrefix = mCoordLinePrefix self.mAreaType = mAreaType self.mLineType = mLineType self.mPointType = mPointType self.mIgnoreZeroElevations = mIgnoreZeroElevations self.mFillToBounds = mFillToBounds self.mOffsetX = mOffsetX self.mOffsetY = mOffsetY self.mOffsetZ = mOffsetZ self.mScaleX = mScaleX self.mScaleY = mScaleY self.mScaleZ = mScaleZ self.mNoDataDistanceFactor = mNoDataDistanceFactor self.mBreakOnColumnIdx = mBreakOnColumnIdx self.mCoordFormat = mCoordFormat
[docs]class Color_t(gm.GM_Color_t): """This type is used when returning a color Color_t(mRed: int = 0, mGreen: int = 0, mBlue: int = 0) Parameters _____________ mRed: int, uint8 Red component of color mGreen: int, uint8 Green component of color mBlue: int, uint8 Blue component of color """ # Requires suitable default arguments def __init__(self, mRed: int = 0, mGreen: int = 0, mBlue: int = 0) : super().__init__() # Fields self.mRed = mRed self.mGreen = mGreen self.mBlue = mBlue
[docs]class Rectangle_t(gm.GM_Rectangle_t): """This type describes a bounding rectangle in world coordinates Rectangle_t(mMinX: float = 0, mMinY: float = 0, mMaxX: float = 0, mMaxY: float = 0) Parameters _____________ mMinX: float Minimum x/easting/longitude coordinate mMinY: float Minimum y/northing/latitude coordinate mMaxX: float Maximum x/easting/longitude coordinate mMaxY: float Maximum y/northing/latitude coordinate """ def __init__(self, mMinX: float = 0, mMinY: float = 0, mMaxX: float = 0, mMaxY: float = 0): super().__init__() # Fields self.mMinX = mMinX self.mMinY = mMinY self.mMaxX = mMaxX self.mMaxY = mMaxY
[docs]class ContourParams_t(gm.GM_ContourParams_t): """This type is used to provide the parameters for generating contours ContourParams_t(mSize: int = 0, mDesc: str = None, mContourBounds: Rectangle_t = Rectangle_t(), mContourInterval: float = 20.0, mIntervalInFeet: bool = False, mGenerateAreas: bool = False, mGenerateSpotElevs: bool = True, mNumberOnlyLabels: bool = False, mShowProgress: bool = True, mDisableSmoothing: bool = False, mCreateFromAbove: bool = False, mSingleLevelOnly: bool = False, mXSpacing: float = 0.0, mYSpacing: float = 0.0, mSimpThreshold: float = 0.0) Parameters ___________ mSize: int (uint32) Size mDesc: str Contour layer description mContourBounds: Rectangle_t Bounds of contour lines to create. Pass empty rectangle to use entirety of passed in layer(s). mContourInterval: float Contour interval mIntervalInFeet: bool Set to TRUE if the contour interval is in feet rather than meters mGenerateAreas: bool Generate iso-height areas in addition to contour lines mGenerateSpotElevs: bool Generate spot elevation points at minimum and maximum elevations mNumberOnlyLabels: bool Only include the value (and not the units string) in the contour labels mShowProgress: bool Display contour generation progress dialog mDisableSmoothing: bool Do not smooth the generated contour lines to improve their appearance mCreateFromAbove: bool ADVANCED: Create contours as we go from above to contour rather than from contour to below. mSingleLevelOnly: bool Only create a single contour level rather than treating as interval mXSpacing: float Sample spacing in the x direction mYSpacing: float Sample spacing in the y direction mSimpThreshold: float Simplification threshold, use 0.0 for no simplification """ def __init__(self, mSize: int = 0, mDesc: str = None, mContourBounds: Rectangle_t = Rectangle_t(), mContourInterval: float = 20.0, mIntervalInFeet: bool = False, mGenerateAreas: bool = False, mGenerateSpotElevs: bool = True, mNumberOnlyLabels: bool = False, mShowProgress: bool = True, mDisableSmoothing: bool = False, mCreateFromAbove: bool = False, mSingleLevelOnly: bool = False, mXSpacing: float = 0.0, mYSpacing: float = 0.0, mSimpThreshold: float = 0.0): super().__init__() self.mSize = mSize self.mDesc = mDesc self.mContourBounds = mContourBounds self.mContourInterval = mContourInterval self.mIntervalInFeet = mIntervalInFeet self.mGenerateAreas = mGenerateAreas self.mGenerateSpotElevs = mGenerateSpotElevs self.mNumberOnlyLabels = mNumberOnlyLabels self.mShowProgress = mShowProgress self.mDisableSmoothing = mDisableSmoothing self.mCreateFromAbove = mCreateFromAbove self.mSingleLevelOnly = mSingleLevelOnly self.mXSpacing = mXSpacing self.mYSpacing = mYSpacing self.mSimpThreshold = mSimpThreshold
[docs]class DatumInfo_t(gm.GM_DatumInfo_t): """This type represents information about a datum DatumInfo_t(mMethod=gm.GM_Datum_Molodensky, mDatumName: str = None, mEllipsoidName: str = None, mDeltaX: float = 0.5, mDeltaY: float = 0.5, mDeltaZ: float = 0.5,mScale: float = 1,mRotX: float = 0.0, mRotY: float = 0.0, mRotZ: float = 0.0, mPrimeMeridian: float = 0.0, mPrimeMeridianName: str = None, mSemiMajor: float = 1, mSemiMinor: float = 1) Parameters ______________ mMethod: GM_DatumXForm_t32 Transformation method mDatumName: str Name of datum mEllipsoidName: str Name of ellipsoid this datum is based on mDeltaX: float Delta X in meters mDeltaY: float Delta Y in meters mDeltaZ: float Delta Z in meters mScale: float Scale factor (GM_Datum_BursaWolfe only) mRotX: float Rotation in X in arc seconds (GM_Datum_BursaWolfe only) mRotY: float Rotation in Y in arc seconds (GM_Datum_BursaWolfe only) mRotZ: float Rotation in Z in arc seconds (GM_Datum_BursaWolfe only) mPrimeMeridian: float Prime meridian for datum (0.0 for Greenwich) mPrimeMeridianName: str Optional name of prime meridian mSemiMajor: float Ellipsoid semi-major axis (output only) mSemiMinor: float Ellipsoid semi-major axis (output only) """ def __init__(self, mMethod=gm.GM_Datum_Molodensky, mDatumName: str = None, mEllipsoidName: str = None, mDeltaX: float = 0.5, mDeltaY: float = 0.5, mDeltaZ: float = 0.5,mScale: float = 1,mRotX: float = 0.0, mRotY: float = 0.0, mRotZ: float = 0.0, mPrimeMeridian: float = 0.0, mPrimeMeridianName: str = None, mSemiMajor: float = 1, mSemiMinor: float = 1): super().__init__() # Fields self.mMethod = mMethod self.mDatumName = mDatumName self.mEllipsoidName = mEllipsoidName self.mDeltaX = mDeltaX self.mDeltaY = mDeltaY self.mDeltaZ = mDeltaZ self.mScale = mScale self.mRotX = mRotX self.mRotY = mRotY self.mRotZ = mRotZ self.mPrimeMeridian = mPrimeMeridian self.mPrimeMeridianName = mPrimeMeridianName self.mSemiMajor = mSemiMajor self.mSemiMinor = mSemiMinor
[docs]class DensityGridParams_t(gm.GM_DensityGridParams_t): """Class to define options for calculating a density grid DensityGridParams_t(mBoundingBox: Rectangle_t = Rectangle_t(), mAreaUnits = gm.GM_AREA_SQ_KM, mCellsPerRadius: int = 3, mField: str = '', mFlags = gm.GM_DensityFlags_DisableProgress, mKernelType = gm.GM_KernelType_Gaussian, mLayerDesc: str = 'Density grid_test_GM_attrtibute', mRadiusMeters: float = 6) Parameters ___________ mFlags: GM_DensityGridFlags_t32 Flags for density grid generation mKernelType: GM_DensityKernelType_t8 The Kernel Type mRadiusMeters: float Radius in meters for kernel (use 0 for a default) mCellsPerRadius: int How many cells in each direction to have per radius (use 0 to use default of 3 cells in each direction per radius) mLayerDesc: str Description to use for new layer, or NULL/empty for default mField: str Name of attribute field to compute on. Set to NULL/empty string to just count points mAreaUnits: GM_AreaUnits_t8 Units of area measure BoundingBox: Rectangle Bounding box in layer units. Provide empty box to use default of entire layer. """ def __init__(self, mFlags=gm.GM_DensityFlags_DisableProgress, mKernelType=gm.GM_KernelType_Gaussian, mRadiusMeters: float = 6, mCellsPerRadius: int = 3, mLayerDesc: str = 'Density grid_test_GM_attrtibute', mField: str = '', mAreaUnits=gm.GM_AREA_SQ_KM, mBoundingBox: Rectangle_t = Rectangle_t()): super().__init__() # Properties self.mFlags = mFlags self.mKernelType = mKernelType self.mRadiusMeters = mRadiusMeters self.mCellsPerRadius = mCellsPerRadius self.mLayerDesc = mLayerDesc self.mField = mField self.mAreaUnits = mAreaUnits self.mBoundingBox = mBoundingBox
[docs]class ElevationOverrides_t(gm.GM_ElevationOverrides_t): """This type represents any adjustments to apply to elevation values within a gridded elevation layer. ElevationOverrides_t(mMaxElev: float, mMinElev: float, mOffset: float, mClampVals: bool = True, mMaxValid: bool = True, mMinValid: bool = True, mVoidValid: bool = True, mLayerShader: str = None, mScale: float = 1.0, mVoidElev: float = 0.5) Parameters ____________ mOffset: float Offset to apply to elevations in meters mScale: float Scale factor to apply mClampVals: bool Clamp out of range values to specified min/max mMinValid: bool Is the new minimum elevation valid mMinElev: float Minimum valid elevation (meters) mMaxValid: bool Is the new maximum elevation valid mMaxElev: float Maximum valid elevation (meters) mVoidValid: bool Is the void elevation value valid? mElevUnits: GM_ElevUnits_t8 Native elevation units for file. mVoidElev: float Elevation to use for void values mLayerShader: str Name of elevation shader to use for layer (NULL for default shared shader) """ def __init__(self, mOffset: float, mScale: float = 1.0, mClampVals: bool = True, mMinValid: bool = False, mMinElev: float = 0.0, mMaxValid: bool = False, mMaxElev: float = 0.0, mVoidValid: bool = True, mElevUnits=gm.GM_ElevUnit_Meters, mVoidElev: float = 0.5,mLayerShader: str = None): super().__init__() # Properies self.mOffset = mOffset self.mScale = mScale self.mClampVals = mClampVals self.mMinValid = mMinValid self.mMinElev = mMinElev self.mMaxValid = mMaxValid self.mMaxElev = mMaxElev self.mVoidValid = mVoidValid self.mElevUnits = mElevUnits self.mVoidElev = mVoidElev self.mLayerShader = mLayerShader
[docs]class EqualValueAreaSetup_t(gm.GM_EqualValueAreaSetup_t): """This type is used to provide the parameters for performing Generate Areas from Equal Values process EqualValueAreaSetup_t( mAreaType = gm.AFC_MIN, mBounds: Rectangle_t= Rectangle_t(), mColorDist: int = 20, mColorList: int = None, mColorListSize: int = 30, mElevDist: float = 5, mFlags = gm.GM_EqualValueArea_ForceRGB, mLayerDesc: str = 'Equal Value area', mSlopeDist: float = 10, mValAttrFormat: str = None, mValAttrName: str = 'color') Parameters ______________ mFlags: GM_EqualValueAreaFlags_t32 Flags controlling the operation mValAttrName: str Name of attribute to save value (color/elev/slope) in mAreaType: AreaFeatureClass_t16 Area type to assign to area features mColorDist: int, sint32 Allowed fudge factor for colors mElevDist: float Allowed difference for elevations mSlopeDist: float Allowed difference for slopes mBounds: Rectangle_t nBounds to create in (empty means all) mColorList: COLORREF, int List of colors to consider (NULL for all) mColorListSize: int Number of colors in the list of colors to consider mValAttrFormat: str Formatting string to use for value attribute (NULL is default, can be C-style format string like "RGB( %d, %d, %d )" or "#%02X%02X%02X"). Must have 3 values for color, 1 for slope or elevation. mLayerDesc: str Name of the resulting layer mElevRangeHigh: float Maximum elevation mElevRangeLow: float Minimum elevation """ def __init__(self, mFlags=gm.GM_EqualValueArea_ForceRGB, mValAttrName: str = 'color', mAreaType=gm.AFC_MIN, mColorDist: int = 20, mElevDist: float = 5, mSlopeDist: float = 10, mBounds: Rectangle_t = Rectangle_t(),mColorList: gm.COLORREF_array = None, mColorListSize: int = 0, mValAttrFormat: str = None,mLayerDesc: str = 'Equal Value area', mElevRangeHigh: float=0, mElevRangeLow: float=0): super().__init__() self.mFlags = mFlags self.mValAttrName = mValAttrName self.mAreaType = mAreaType self.mColorDist = mColorDist self.mElevDist = mElevDist self.mSlopeDist = mSlopeDist self.mBounds = mBounds self.mColorList = mColorList self.mColorListSize = mColorListSize self.mValAttrFormat = mValAttrFormat self.mLayerDesc = mLayerDesc self.mColorListSize = mColorListSize self.mValAttrFormat = mValAttrFormat self.mLayerDesc = mLayerDesc self.mElevRangeHigh = mElevRangeHigh self.mElevRangeLow = mElevRangeLow
[docs]class ExportOptsDXF_DWG_t(gm.GM_ExportOptsDXF_DWG_t): """This type is used to describe custom export options for DXF/DWG vector exports ExportOptsDXF_DWG_t( mDWGVersion = gm.GM_ExportDWG_VerDefault, mFlags = gm.GM_ExportDXF_UseLabelsForLayers, mLabelType = gm.GM_ExportDXF_LabelsAsPointsFeatureLayer, mLayerAttr: str = None, mTenPointFontHeight: float = 10, mCADType = gm.GM_CADType_DWG) Parameters ____________ mTenPointFontHeight: float Height (in ground units) to use for 10 pt label fonts (other sizes will be scaled appropriately) mLabelType:GM_ExportOptsDXFLabels_t8 Export setting for area and line feature labels mDWGVersion: GM_ExportOptsDWGVersion_t8 DWG export only: version mFlags: GM_ExportOptsDXFFlags_t32 Export Flags mCADType: GM_ExportOptsCADType_t8 CAD export type (only used when passed into DWGExporter::Export()) mLayerAttr: str Attribute value to get layer name from (NULL to use description/type) """ def __init__(self, mTenPointFontHeight: float = 10, mLabelType=gm.GM_ExportDXF_LabelsAsPointsFeatureLayer, mDWGVersion=gm.GM_ExportDWG_VerDefault, mFlags=gm.GM_ExportDXF_UseLabelsForLayers, mCADType=gm.GM_CADType_DWG, mLayerAttr: str = None): super().__init__() # Fields self.mTenPointFontHeight = mTenPointFontHeight self.mLabelType = mLabelType self.mDWGVersion = mDWGVersion self.mFlags = mFlags self.mCADType = mCADType self.mLayerAttr = mLayerAttr
[docs]class ExportOptsKML_t(gm.GM_ExportOptsKML_t): """This type is used to describe custom export options for KML vector exports. To create a KMZ file, pass a filename with a .kmz extension to the GM_ExportVector function. ExportOptsKML_t( mAreaDisplayAtElev: bool = False, mAreaElevsRelative: bool = False, mExtrudeAreas: bool = False, mHidePointsInitially: bool = True, mLineDisplayAtElev: bool = True, mLineElevsRelativev: bool = False, mAreaOpacity: float = 100) Parameters ____________ mAreaOpacity: float area translucency - percent (0.0 - 100.0) mAreaDisplayAtElev: bool display area features at feature elevation mAreaElevsRelative: bool area elevations relative to ground (only valid if mAreaDisplayAtElev set) mExtrudeAreas: bool extrude 3D areas to make 3D shapes like buildings (only valid if mAreaDisplayAtElev set) mLineDisplayAtElev: bool display line features at feature elevation mLineElevsRelative: bool line elevations relative to ground (only valid if mLineDisplayAtElev set) mHidePointsInitially: bool initially hide point features when displayed in Google Earth """ def __init__(self, mAreaOpacity: float = 100, mAreaDisplayAtElev: bool = False, mAreaElevsRelative: bool = False, mExtrudeAreas: bool = False, mLineDisplayAtElev: bool = True, mLineElevsRelative: bool = False, mHidePointsInitially: bool = True): super().__init__() # Properties self.mAreaOpacity = mAreaOpacity self.mAreaDisplayAtElev = mAreaDisplayAtElev self.mAreaElevsRelative = mAreaElevsRelative self.mExtrudeAreas = mExtrudeAreas self.mHidePointsInitially = mHidePointsInitially self.mLineDisplayAtElev = mLineDisplayAtElev self.mLineElevsRelative = mLineElevsRelative
[docs]class ExportOptsPDF_t(gm.GM_ExportOptsPDF_t): """Describes custom export options for DWG exports ExportOptsPDF_t( mFlags = gm.GM_PDF_FillPage, mPageSizeName = 'Letter', mDPI = 150, mMarginRect = Rectangle_t(0.5, 1.0, 0.5, 0.5), mHeaderStr: str = 'Default obj value', mHeaderFront = None, mFooterStr = None, mFooterFont = None, mSymbolScale = 0.0, mBorderStyle = gm.GM_PEN_SOLID, mBorderWidth = 3, mBordercolor = 0 Parameters ___________ mFlags:GM_PDFExportFlags_t32 Export flags mPageSizeName: str Name of page size, like "Letter", "Legal", "A0", etc. mDPI: int, uint32 Export DPI mMarginRect: Rectangle Margins for each side in inches mHeaderStr: str Header for page (None for none) mHeaderFont: FontDef (const GM_FontDef_t) Header font (NULL for default) mFooterStr: str Footer for page (None for none) mFooterFont: FontDef Footer font (None for default) mSymbolScale: float Point symbol scaling factor (0.0 will be treated as 1.0, use 2.0 to double size, 0.5 to half size, etc.) mBorderStyle: GM_PenStyle_t16 Border pen style (i.e. solid, dash, etc.) mBorderWidth: int, uint16 Border width in PDF points (pixels) mBorderColor: color, int Border line color """ def __init__(self, mFlags=gm.GM_PDF_FillPage, mPageSizeName: str = 'Letter', mDPI: int = 150, mMarginRect: Rectangle_t = Rectangle_t(0.5, 1.0, 0.5, 0.5), mHeaderStr: str = 'Default obj value', mHeaderFont: FontDef_t = None, mFooterStr: str = None, mFooterFont: FontDef_t = None, mSymbolScale: float = 0.0, mBorderStyle=gm.GM_PEN_SOLID, mBorderWidth: int = 3, mBorderColor: int = 0): super().__init__() self.mFlags = mFlags self.mPageSizeName = mPageSizeName self.mDPI = mDPI self.mMarginRect = mMarginRect self.mHeaderStr = mHeaderStr self.mHeaderFont = mHeaderFont self.mFooterFont = mFooterFont self.mFooterStr = mFooterStr self.mSymbolScale = mSymbolScale self.mBorderStyle = mBorderStyle self.mBorderWidth = mBorderWidth self.mBorderColor = mBorderColor
[docs]class ExportOptsSHP_t(gm.GM_ExportOptsSHP_t): """This type is used to describe custom export options for Shapefile vector exports ExportOptsSHP_t( mAddLabelAttr = True, mAddLayerAttr = True) Parameters ___________ mAddLabelAttr: bool Include the display label as a LABEL attribute if present mAddLayerAttr: bool Add LAYER and GM_TYPE attribute values """ def __init__(self, mAddLabelAttr: bool = True, mAddLayerAttr: bool = True): super().__init__() self.mAddLabelAttr = mAddLabelAttr self.mAddLayerAttr = mAddLayerAttr
[docs]class ExportOptsSimpleText_t(gm.GM_ExportOptsSimpleText_t): """This type is used to describe custom export options for Simple Text vector exports ExportOptsSimpleText_t(mCoordSep: str = None, mFeatureSep: str = None, mAddLayerAttr: bool = True, mYCoordFirst: bool = True, mReserved1: bytes = 0, mReserved2: bytes = 0) Parameters ___________ mCoordSep: str Coordinate separator (use None for default of comma) mFeatureSepFeature: str separator (use None for default of blank line) mAddStyleAttrs: bool Include style attributes if attributes are included mYCoordFirst: bool Export Y/latitude/northing before X/longitude/easting mReserved1: int, uint8 Reserved (for padding), must be 0 mReserved2:: int, uint8 Reserved (for padding), must be 0 """ def __init__(self, mCoordSep: str = None, mFeatureSep: str = None, mAddStyleAttrs: bool = True, mYCoordFirst: bool = True, mReserved1: int = 0, mReserved2: int = 0): super().__init__() self.mAddStyleAttrs = mAddStyleAttrs self.mYCoordFirst = mYCoordFirst self.mCoordSep = mCoordSep self.mFeatureSep = mFeatureSep self.mReserved1 = mReserved1 self.mReserved2 = mReserved2
[docs]class ExportOptsGeoPackage_t(gm.GM_ExportOptsGeoPackage_t): """This type is used to describe custom export options for GeoPackage exports ExportOptsGeoPackage_t(mOverwriteExisting: bool = False, mAreaTableName: str = None, mLineTableName: str = None, mPointTableName: str = None, mSplitByLayer: bool = False, mGen3dFeatures: bool = False, mTileTableName: str = None, mDescription: str = 'Default Tile Layer', mMaxZoomLevel: int = 3, mNumZoomLevels:int = 5, mImageFormat: int = gm.GM_Export_GeoTIFF, mImageQuality: int = 75, mTileSize: int = 256, mFlags = gm.GM_WebExport_NoTransparency) Parameters ____________ mOverwriteExisting: bool Indicates whether or not to overwrite an existing GeoPackage file mAreaTableName: string Table name for area features. NULL if not exporting areas. For Vector Export. mLineTableName: string Table name for line features. NULL if not exporting lines. For Vector Export. mPointTableName: string Table name for point features. NULL if not exporting points. For Vector Export. mSplitByLayer: bool Indicates whether or not to split features in to separate tables by layer. For Vector Export. mGen3dFeatures: bool Indicates whether or not to create 3D features. For Vector Export. mTileTableName: String Table name for raster tiles. NULL for default "tile_data". For Raster Export. mDescription: String Description for tile layer. For Raster Export. mMaxZoomLevel: int, sint32 Maximum zoom level to export. Valid range is 3 to 22. For Raster Export. mNumZoomLevels: int, uint32 Total number of zoom levels to export. For Raster Export. mImageFormat: GM_RasterExportFormat_t32 Image format (PNG or JPEG). For Raster Export. mImageQuality: int, uint32 Image quality. Applies only to JPEG exports. Range is 1 to 100. Default is 75. For Raster Export. mTileSize: int, uint32 Tile size in pixels. Valid values are 256, 512, and 1024. Default is 256. Tiles are square, so 256 means 256 x 256 pixel tiles. For Raster Export. mFlags: GM_WebExportFlags_t32 Additional related for skipping empty tiles, skipping tiles that already exist, etc. For Raster Export. """ def __init__(self, mOverwriteExisting: bool = False, mAreaTableName: str = None, mLineTableName: str = None, mPointTableName: str = None, mSplitByLayer: bool = False, mGen3dFeatures: bool = False, mTileTableName: str = None, mDescription: str = 'Default Tile Layer', mMaxZoomLevel: int = 3, mNumZoomLevels:int = 5, mImageFormat: int = gm.GM_Export_GeoTIFF, mImageQuality: int = 75, mTileSize: int = 256, mFlags = gm.GM_WebExport_NoTransparency): super().__init__() self.mOverwriteExisting = mOverwriteExisting self.mAreaTableName = mAreaTableName self.mLineTableName = mLineTableName self.mPointTableName = mPointTableName self.mSplitByLayer = mSplitByLayer self.mGen3dFeatures = mGen3dFeatures self.mTileTableName = mTileTableName self.mDescription = mDescription self.mMaxZoomLevel = mMaxZoomLevel self.mNumZoomLevels = mNumZoomLevels self.mImageFormat = mImageFormat self.mImageQuality = mImageQuality self.mTileSize = mTileSize self.mFlags = mFlags
[docs]class FeatureClassInfo_t(gm.GM_FeatureClassInfo_t): """This type is used to return information about a given feature classification FeatureClassInfo_t( mIsEnabled: bool = False, mPriority: bool = False, mZLevel = gm.Z_LVL_MIN, mDesc: str = None) Parameters ______________ mIsEnabled: bool Is display of this class enabled? mPriority: bool Draw priority (0-255). Controls when features show up in zoom levels. mZLevel: ZLevel_t16 Z level for feature mDesc: str Description string for this feature """ def __init__(self, mIsEnabled: bool = False, mPriority: int = 1, mZLevel=gm.Z_LVL_MIN, mDesc: str = None): super().__init__() # Properties self.mIsEnabled = mIsEnabled self.mPriority = mPriority # Fields self.mDesc = mDesc self.mZLevel = mZLevel
[docs]class FillGapsParams_t(gm.GM_FillGapsParams_t): # TODO no class information in the SDK description """Structure defining parameters for gap filling FillGapsParams_t( mGridAlg = gm.GM_GridAlg_None, mGapAlg = gm.GM_GapFillAlg_None, mDirsToRequire: int = 4, mMaxThreads: int = 4, mMaxDist: int = 10, mMinDist: int = 1, mMaxPointCount: int = 5, mPowerParameter: int = 5) Parameters ____________ mGridAlg: GM_GridAlg_t8 Algorithm to used for creating elevation grid (used for creating pyramid grids) mGapAlg: GM_GridGapFillAlg_t8 Algorithm to use for filling gaps mDirsToRequire: int, uint32 how many cardinal directions to require (4 for all 4) mMaxThreads: int, uint32 maximum background threads to spawn (0 for default) mMaxDist: int, uint32 maximum distance (in samples) from center to search mMinDist: int, uint32 minimum distance (in samples) from center to search mMaxPointCount: int, uint32 maximum number of points to consider (0 for no maximum) mPowerParameter: int, uint32 the power parameter to use in IDW calculations """ def __init__(self, mGridAlg: int, mGapAlg: int, mDirsToRequire: int, mMaxThreads: int = 0,mMaxDist: int = 0, mMinDist: int = 0, mMaxPointCount: int = 5, mPowerParameter: int = 5): super().__init__() self.mGridAlg = mGridAlg self.mGapAlg = mGapAlg self.mDirsToRequire = mDirsToRequire self.mMaxThreads = mMaxThreads self.mMaxDist = mMaxDist self.mMinDist = mMinDist self.mMaxPointCount = mMaxPointCount self.mPowerParameter = mPowerParameter
[docs]class GPS_Position_t(gm.GM_GPS_Position_t): """Structure for holding GPS position Parameters __________ mLat:float Latitude mLon:float Longitude """ def __init__(self, lat: float = 0, lon: float = 0): super().__init__() self.mLat = lat self.mLon = lon
[docs]class GPS_Waypoint_t(gm.GM_GPS_Waypoint_t): """Structure for holding GPS waypoint information Parameters ___________ mPos: GM_GPS_Position_t Current location (lat/lon radians) mAltitude: float Altitude above sea level in meters mName: str Waypoint name mGroupId: int Group ID (0 - 99) mIcon: int Icon (0-99) mSerialCode: int Serial code of sender mTimeStamp: time_t UTC time of waypoint creation """ def __init__(self, mPos: GPS_Position_t = GPS_Position_t(0, 0), mAltitude: float = 0, mName: str = "", mGroupId: int = 0, mIcon: int = 0, mSerialCode: int = 0): super().__init__() # TODO: figure out how to handle mTimestamp of type time_t self.mPos = mPos self.mAltitude = mAltitude self.mName = mName self.mGroupId = mGroupId self.mIcon = mIcon self.mSerialCode = mSerialCode
[docs]class GPS_Text_Msg_t(gm.GM_GPS_Text_Msg_t): """Structure for holding GPS text message information Parameters ___________ mDeviceName: str Sending device name mMessage: str Message mGroupID: int Group ID (0 - 99) mIcon: int Icon (0-99) mSerialCode: int Serial code of sender mTimeStamp: time_t UTC time of message transmission """ def __init__(self, mDeviceName: str = "", mMessage: str = "", mGroupId: int = 0, mIcon: int = 0, mSerialCode: int = 0): super().__init__() # TODO: figure out how to handle mTimestamp of type time_t self.mDeviceName = mDeviceName self.mMessage = mMessage self.mGroupId = mGroupId self.mIcon = mIcon self.mSerialCode = mSerialCode
[docs]class GridCombineSetup_t(gm.GM_GridCombineSetup_t): """This type represents the input needed for creating a new grid layer by combining 2 input grid layers GridCombineSetup_t(mCombineOp, mLayer1, mLayer2, mRectBounds: Rectangle_t = Rectangle_t(), mXRes: float = 0.0, mYRes: float = 0.0,mDesc: str = 'Grid setup description', mFlags = gm.GM_CombineOp_FillGaps, mElevUnits = gm.GM_ElevUnit_Meters, mCompareVal: float = 1.5) Parameters _______________ mCombineOp: GM_CombineOp_t8 Combine operation mLayer1: GM_LayerHandle_t32 First input grid layer mLayer2: GM_LayerHandle_t32 Second input grid layer mRectBounds: Rectangle_t Bounding rectangle in current projection in which to perform operation. Keep at null rectangle (all zero values) to use default of intersection of input grid layers. mXRes: float X resolution (in current proj units) to generate grid at (use 0.0 for auto-spacing determination) mYRes: float Y resolution (in current proj units) to generate grid at (use 0.0 for auto-spacing determination) mDesc: str Grid description mFlags: GM_CombineOpFlags_t32 Flags to control operation mElevUnits: GM_ElevUnits_t8 Elevation units for new grid layer mCompareVal: float Compare value to use for operations that compare to a value """ def __init__(self, mCombineOp, mLayer1, mLayer2, mRectBounds: Rectangle_t = Rectangle_t(), mXRes: float = 0.0, mYRes: float = 0.0, mDesc: str = 'Grid setup description', mFlags=gm.GM_CombineOp_FillGaps, mElevUnits=gm.GM_ElevUnit_Meters, mCompareVal: float = 1.5): super().__init__() # properties self.mLayer1 = mLayer1 self.mLayer2 = mLayer2 self.mRectBounds = mRectBounds # Fields self.mCombineOp = mCombineOp self.mCompareVal = mCompareVal self.mDesc = mDesc self.mElevUnits = mElevUnits self.mFlags = mFlags self.mXRes = mXRes self.mYRes = mYRes
[docs]class GridGenSetup_t(gm.GM_GridGenSetup_t): """Object containing the inputs needed for gridding a set of vector data GridGenSetup_t(mDesc = None, mFlags = gm.GM_GridGen_NoConstraints, mXRes = 0.0, mYRes = 0.0, mElevUnits = gm.GM_PRJ_UNIT_METERS, mGridAlg = gm.GM_GridAlg_DefaultLidar, mLidarField = gm.GM_LidarGrid_Elevation, mBandType = gm.GM_VAL_U8,mLidarBreaklineBinMult = 2, mBounds = None, mTightnessMult = gm.GM_GRID_DISABLE_GAP_FILL, mTaperValue = 0.0, mGapFillSetup = None) Parameters _______________ mDesc: str Grid description mFlags: GM_GridGenFlags_t32 Flags for grid generation mXRes: float X resolution (in current proj units) to generate grid at (use 0.0 for auto-spacing determination) mYRes: float Y resolution (in current proj units) to generate grid at (use 0.0 for auto-spacing determination) mElevUnits: UNIT Units to generate grid at (elevation values in other units will be converted as needed) mGridAlg: GM_GridAlg_t8 Algorithm to use for creating elevation grid (if any) mLidarField: GM_LidarGridField_t8 Field of Lidar data to grid if gridding Lidar point clouds mBandType: str Band type to use for non-elevation gridding mLidarBreaklineBinMult: GM_LidarGridField_t8 Number of cells to clear from a Lidar grid around 3D breaklines before applying breakline heights and filling gaps (valid if GM_GridGen_ApplyLidarBreaklines used). Typically in range 1-4. mBounds: Rectangle_t (GM_Rectangle_t)Bounding box to grid to in current proj units. Pass NULL to use the combined bounds of all input layers (the default). mTightnessMult: float Grid tightness multiplier (multiplies resolution) for discarding values far from a sample. Default of zero discards nothing. For Lidar bin gridding you typically do NOT want to use 0 as it it can be very slow to fill all gaps in irregular Lidar data. Use GM_GRID_DISABLE_GAP_FILL to disable gap filling altogether. For Lidar bin grids, gap fill values in the range 1-32 are common. mGridBinMult: float Grid bin multiplier for use if using a bin-based grid method. This is multiple of calculated point density. mTaperValue: float Taper value for gridding areas. 0.0 for no taper (default) mGapFillSetup: FillGapsParams_t Parameters to perform gap fill operations. Use NULL for default parameters. """ def __init__(self, mDesc: str = None, mFlags=gm.GM_GridGen_NoConstraints, mXRes: float = 0.0, mYRes: float = 0.0, mElevUnits=gm.GM_PRJ_UNIT_METERS, mGridAlg=gm.GM_GridAlg_DefaultLidar, mLidarField=gm.GM_LidarGrid_Elevation, mBandType=gm.GM_VAL_U8, mLidarBreaklineBinMult: int = 2, mBounds: Rectangle_t = Rectangle_t(), mTightnessMult: float = 1.005, mGridBinMult: float = 0, mTaperValue: float = 0.0, mGapFillSetup: FillGapsParams_t = None): super().__init__() self.mDesc = mDesc self.mFlags = mFlags self.mXRes = mXRes self.mYRes = mYRes self.mElevUnits = mElevUnits self.mGridAlg = mGridAlg self.mLidarField = mLidarField self.mBandType = mBandType self.mLidarBreaklineBinMult = mLidarBreaklineBinMult self.mBounds = mBounds self.mTightnessMult = mTightnessMult self.mGridBinMult = mGridBinMult self.mTaperValue = mTaperValue self.mGapFillSetup = mGapFillSetup
[docs]class GridLayout_t(gm.GM_GridLayout_t): """This type represents layout information for a new elevation grid layer GridLayout_t( mFlags = gm.GM_RasterLayout_BGROrder, mTopLeft: Point_t = Point_t(0,0), mXSpacing: float = 1.005, mYSpacing: float = 2.005, mNumSamplesX: int = 100, mNumSamplesY: int = 100, mBytesPerRow: int = 256, mNoDataValue: float = 1.00, mValType = gm.GM_VAL_U8, mElevUnits = gm.GM_ElevUnit_Meters, mReserved = 0) Parameters ____________ mFlags: GM_RasterLayoutFlags_t32 General flags for layout. mTopLeft: Point_t Ground coordinates of center of the top left pixel mXSpacing: float Spacing of sample cells in the X direction mYSpacing: float Spacing of sample cells in the Y direction mNumSamplesX: int, sint32 Number of pixels in the x direction mNumSamplesY: int, sint32 Number of pixels in the y direction mBytesPerRow: int, uint32 Number of bytes per row of data in data buffer. If 0 this will be calculated for you. mNoDataValue: float Value of samples for which the value isn't known (i.e. -9999.9) mValType: GM_BandValType_t8 Band value type mElevUnits: GM_ElevUnits_t8 Elevation units mReserved: int, uint8 Reserved for alignment purposes """ def __init__(self, mFlags = gm.GM_RasterLayout_BGROrder, mTopLeft: Point_t = Point_t(0,0), mXSpacing: float = 1.005, mYSpacing: float = 2.005, mNumSamplesX: int = 100, mNumSamplesY: int = 100, mBytesPerRow: int = 256, mNoDataValue: float = 1.00, mValType = gm.GM_VAL_U8, mElevUnits = gm.GM_ElevUnit_Meters, mReserved = 0): super().__init__() self.mFlags = mFlags self.mTopLeft = mTopLeft self.mXSpacing = mXSpacing self.mYSpacing = mYSpacing self.mNumSamplesX = mNumSamplesX self.mNumSamplesY = mNumSamplesY self.mBytesPerRow = mBytesPerRow self.mNoDataValue = mNoDataValue self.mValType = mValType self.mElevUnits = mElevUnits
#self.mReserved = mReserved
[docs]class ProjAttrValue_t(gm.GM_ProjAttrValue_t): """This type is used to describe a single projection attribute value ProjAttrValue_t( mAttr = gm.CENTRAL_LONGITUDE, mValue = 0.0) Parameters _____________ mAttr: PROJATTR Attribute mValue: float Attribute value """ def __init__(self, mAttr: int=gm.CENTRAL_LONGITUDE, mValue: float=0.0): super().__init__() # Fields self.mAttr = mAttr self.mValue = mValue
[docs]class Projection_t(gm.GM_Projection_t): """This type is used to fully describe a projection. Projection_t(mProjSys: int = gm.GM_PRJ_GEO, mDatum: int = gm.GM_DATUM_WGS_84, mUnit: int = gm.GM_PRJ_UNIT_METERS, mAttrList=None) Parameters ___________ mProjSys: PROJSYS, int Projection system mDatum: DATUM, int Horizontal datum mUnit: UNIT, int Ground units mNumAttrs: int Size of mAttrList mAttrList: GM_ProjAttrValue_t Attribute value list items """ def __init__(self, mProjSys: int = gm.GM_PRJ_GEO, mDatum: int = gm.GM_DATUM_WGS_84, mUnit: int = gm.GM_PRJ_UNIT_METERS, mAttrList=None, mNumAttrs: int=0): super().__init__() # Fields if mAttrList is None: mAttrList = ([gm.GM_ProjAttrValue_t()] * 16) # the attribute list, when set through the = method, must be a list of 16 GM_ProjAttrValue_t objects self.mProjSys = mProjSys self.mDatum = mDatum self.mUnit = mUnit self.mAttrList = mAttrList self.mNumAttrs = mNumAttrs
[docs]class LayerInfo_t(gm.GM_LayerInfo_t): """ This type is used when returning information about a layer LayerInfo_t( mDescription: str = None, mNativeRect: Rectangle_t = Rectangle_t(), mGlobalRect: Rectangle_t = Rectangle_t(), mPixelWidth: int = 1920, mPixelHeight: int = 1080, mNativeProj: Projection_t = Projection_t(), mControlPoints: gm.GM_GroundControlPoint_array = None, mNumGCPs: int = 0, mMinElevation: float = 0.0, mMaxElevation: float = 10.0, mNumAreas: int = 1, mNumLines: int = 1, mNumPoints: int = 0, mPixelSizeX: float = 0.5, mPixelSizeY: float = 0.5, mHasRasterData: bool = False, mEnabled: bool = False, mHasVectorData: bool = False, mUsedDefaultPos: bool = False, mFilename: str = None,mArchiveFilename: str = None, mTypeName: str = None, mGlobalPixelWidth: int = 1920, mGlobalPixelHeight: int = 1080, mMetadataList: gm.GM_AttrValue_array = None, mMetadataListSize: int = 0, mNumBands: int = 1, mExtraLoadFlags: str = None, mPalette: gm.GM_PaletteEntry_array = None, mPaletteSize: int = 0, mUserData: int = 1, mElevUnits=gm.GM_ElevUnit_Meters,mBandValType=gm.GM_VAL_U8, mBandBitDepth: int = 32, mRasterTypeFlags=gm.GM_RasterType_Image, mUserText: str = None, mNumLidarPoints: int = 0, mParentLayer:LayerHandle_t = LayerHandle_t(0), mDfltViewGlobal: Rectangle_t = Rectangle_t(), mCodePage: int = 0, mGroupName: str = None, mUsedDefaultProj: bool = False, mLayerFlags=gm.GM_LayerFlags_Default) Parameters ________________ mFilename: str Filename from which layer was loaded (if this is an archive file, like .zip, then the name of the actual loaded file will be in mArchiveFilename mParentLayer: GM_LayerHandle_t32 Handle to parent layer if this is a child (i.e. from catalog or online layer). NULL for all top-level layers. mDescription: str Description string mNativeRect: Rectangle_t Bounding rect of layer in native coordinates mGlobalRect: Rectangle_t Bounding rect of layer in global coordinates mPixelWidth: int, uint32 RASTER/ELEV ONLY: Number of pixels wide layer is (should be an unsigned integer) mPixelHeight: int, uint32 RASTER/ELEV ONLY: Number of pixels tall layer is (should be an unsigned integer) mNativeProj: Projection_t Native projection of layer mControlPoints: GroundControlPoint_array Ground control points list. Point to GM_GroundControlPoint_t mNumGCPs: int, uint32 RASTER ONLY: Number of ground control points in list mMinElevation: float ELEV ONLY: Minimum elevation in meters mMaxElevation: float ELEV ONLY: Maximum elevation in meters mNumAreas: int, uint32 VECTOR ONLY: Number of area features (should be an unsigned integer) mNumLines: int, uint32 VECTOR ONLY: Number of line features (should be an unsigned integer) mNumPoints: int, uint32 VECTOR ONLY: Number of point features (should be an unsigned integer) mPixelSizeX: float RASTER/ELEV ONLY: Pixel size in meters in the x direction mPixelSizeY: float RASTER/ELEV ONLY: Pixel size in meters in the y direction mHasRasterData: bool Does this layer have raster or elevation data? mEnabled: bool Is this layer enabled for display or it it hidden? mHasVectorData: bool Does this layer have vector data (the features counts can all be 0 for things like map catalogs) mUsedDefaultPos: bool RASTER/ELEV ONLY: Was the default position used for this layer since the file could not be automatically positioned? mArchiveFilename: str Filename within archive file (e.g. .zip or .tar.gz) from which layer was loaded, if any (might be None) mTypeName: str Layer type name mGlobalPixelHeight: int RASTER/ELEV ONLY: Approximate number of pixels required in height for a 1:1 pixel mapping in the current projection (should be an unsigned integer) mGlobalPixelWidth: int RASTER/ELEV ONLY: Approximate number of pixels required in width for a 1:1 pixel mapping in the current projection (should be an unsigned integer) mMetadataList: AttrValue_t List of metadata attributes and values for the layer mMetadataListSize: int List of metadata attributes and values for the layer mNumBands: int Number of bands in a raster image (use GM_SetRasterDisplayOptions to change color band layout) (should be an unsigned integer) mExtraLoadFlags: str Additional load flags with options selected by user during load. Pass these to GM_LoadLayerListEx to remember options. mPalette: PaletteEntry_array List of palette entries for palette-based raster layer mPaletteSize: int, uint32 Number of entries in palette list mUserData: intPtr Custom data associated with layer provided by user via GM_SetLayerUserData function mElevUnits: GM_ElevUnits_t8 Elevation units for layer mBandValType: GM_BandValType_t8 RASTER/ELEV ONLY: type of data for the bands mBandBitDepth: int, uint16 RASTER/ELEV ONLY: number of bits per band value. Multiply by mNumBands to get total bit depth per sample. mRasterTypeFlags: GM_RasterTypeFlags_t32 Raster type flags, specifies what type of data a raster layer actually contains mUserText: str Custom text string associated with layer provided by user via GM_SetLayerUserText function or loaded form workspace. mNumLidarPoints: int, uint64 VECTOR ONLY: Number of Lidar point cloud points (fetch with GM_GetLidarPoint) (Should be an unsigned integer) mDfltViewGlobal: Rectangle_t Default view bounding rect of layer in global coordinates (usually same as mGlobalRect) mCodePage: int, sint32 Code page for text in layer. 0 is default and current active code page (CP_ACP). CP_UTF8 is for UTF-8 interpretation. mGroupName: str Group name that the layer is in. NULL for no group. Separated with <sep> if multiple levels. mUsedDefaultProj: boolean Was the default projection used for this layer since a projection for the file could not be automatically determined? mLayerFlags: GM_LayerFlags_t32 Extra flags for the layer """ # TODO mUserData is handled as void* # TODO mNativeProj requires type Projection_t() def __init__(self, mDescription: str = None, mNativeRect: Rectangle_t = Rectangle_t(), mGlobalRect: Rectangle_t = Rectangle_t(), mPixelWidth: int = 1920, mPixelHeight: int = 1080, mNativeProj: Projection_t = Projection_t(), mControlPoints: gm.GM_GroundControlPoint_array = None, mNumGCPs: int = 0, mMinElevation: float = 0.0, mMaxElevation: float = 10.0, mNumAreas: int = 1, mNumLines: int = 1, mNumPoints: int = 0, mPixelSizeX: float = 0.5, mPixelSizeY: float = 0.5, mHasRasterData: bool = False, mEnabled: bool = False, mHasVectorData: bool = False, mUsedDefaultPos: bool = False, mFilename: str = None,mArchiveFilename: str = None, mTypeName: str = None, mGlobalPixelWidth: int = 1920, mGlobalPixelHeight: int = 1080, mMetadataList: gm.GM_AttrValue_array = None, mMetadataListSize: int = 0, mNumBands: int = 1, mExtraLoadFlags: str = None, mPalette: gm.GM_PaletteEntry_array = None, mPaletteSize: int = 0, mUserData: int = 1, mElevUnits=gm.GM_ElevUnit_Meters,mBandValType=gm.GM_VAL_U8, mBandBitDepth: int = 32, mRasterTypeFlags=gm.GM_RasterType_Image, mUserText: str = None, mNumLidarPoints: int = 0, mParentLayer:LayerHandle_t = LayerHandle_t(0), mDfltViewGlobal: Rectangle_t = Rectangle_t(), mCodePage: int = 0, mGroupName: str = None, mUsedDefaultProj: bool = False, mLayerFlags=gm.GM_LayerFlags_Default): super().__init__() # Properties self.mDescription = mDescription self.mNativeRect = mNativeRect self.mGlobalRect = mGlobalRect self.mPixelWidth = mPixelWidth self.mPixelHeight = mPixelHeight self.mNativeProj = mNativeProj self.mControlPoints = mControlPoints self.mNumGCPs = mNumGCPs self.mMinElevation = mMinElevation self.mMaxElevation = mMaxElevation self.mNumAreas = mNumAreas self.mNumLines = mNumLines self.mNumPoints = mNumPoints self.mPixelSizeX = mPixelSizeX self.mPixelSizeY = mPixelSizeY self.mHasRasterData = mHasRasterData self.mEnabled = mEnabled self.mHasVectorData = mHasVectorData self.mUsedDefaultPos = mUsedDefaultPos self.mFilename = mFilename self.mArchiveFilename = mArchiveFilename self.mTypeName = mTypeName self.mGlobalPixelWidth = mGlobalPixelWidth self.mGlobalPixelHeight = mGlobalPixelHeight self.mMetadataList = mMetadataList # when setting, use "obj.mAttrList = array_var.cast()". Without calling .cast(), it may not always work self.mMetadataListSize = mMetadataListSize self.mNumBands = mNumBands self.mExtraLoadFlags = mExtraLoadFlags self.mPalette = mPalette self.mPaletteSize = mPaletteSize self.mUserData = mUserData self.mElevUnits = mElevUnits self.mBandValType = mBandValType self.mBandBitDepth = mBandBitDepth self.mRasterTypeFlags = mRasterTypeFlags self.mUserText = mUserText self.mNumLidarPoints = mNumLidarPoints self.mParentLayer = mParentLayer self.mDfltViewGlobal = mDfltViewGlobal self.mCodePage = mCodePage self.mGroupName = mGroupName self.mUsedDefaultProj = mUsedDefaultProj self.mLayerFlags = mLayerFlags
[docs]class LineStyle_t(gm.GM_LineStyle_t): """This type is used to describe a style used for drawing a line feature and its label (if any) LineStyle_t(mPenStyle=gm.GM_PEN_SOLID, mPenWidth: int = 0, mPenColor: COLORREF = COLORREF(0), mDrawLabel: bool = True, mDrawLabelAlways: bool = False, mDrawLabelOnLine: bool = False, mExtraStyleData: int = 0, mFont: FontDef_t = FontDef_t(), mLabelSegment: int = 0, mFixedWidthMeters: float = 0.5, mBgPenWidth: int = 0,mBgPenColor: int = int(0)) Parameters ___________ mPenStyle: GM_PenStyle_t16 Pen style (i.e. solid, dash, etc.) mPenWidth: int, uint16 Width in pixels to draw pen in (set to 0 for fixed width lines) mPenColor: COLORREF Color to use for pen mDrawLabel: bool Render the label for this line if there is one mDrawLabelAlways: bool Render the label for this line even if it collides with another display label mDrawLabelOnLine: bool Render the label for this line (if any) directly on the line rather than offset from it mExtraStyleData: int, uint8 Extra parameter for some styles(i.e.scallop height for scallop line styles). Set to 0 for default behavior. mFont: FontDef_t Font to use to render label mLabelSegment: int, sint32 Segment number (1-based) on which to render label (use 0 to use default label placement) mFixedWidthMeters: float Fixed width in meters to use for pen (only used if mPenWidth is zero) mBgPenWidth: int,uint16 For double line pens, the width of the background line; if bg width is > 0, then this is a double line style mBgPenColor: COLORREF For double line pens, the color of the background line """ def __init__(self, mPenStyle=gm.GM_PEN_SOLID, mPenWidth: int = 0, mPenColor: COLORREF = COLORREF(0), mDrawLabel: bool = True, mDrawLabelAlways: bool = False, mDrawLabelOnLine: bool = False, mExtraStyleData: int = 0, mFont: FontDef_t = FontDef_t(), mLabelSegment: int = 0, mFixedWidthMeters: float = 0.5, mBgPenWidth: int = 0,mBgPenColor: int =COLORREF(0)): super().__init__() # Fields self.mPenStyle = mPenStyle self.mPenWidth = mPenWidth self.mPenColor = mPenColor self.mDrawLabel = mDrawLabel self.mDrawLabelAlways = mDrawLabelAlways self.mDrawLabelOnLine = mDrawLabelOnLine self.mExtraStyleData = mExtraStyleData self.mFont = mFont self.mLabelSegment = mLabelSegment self.mFixedWidthMeters = mFixedWidthMeters self.mBgPenWidth = mBgPenWidth self.mBgPenColor = mBgPenColor
[docs]class LineFeature_t(gm.GM_LineFeature_t): """A Managed Definition of a Line Feature LineFeature_t(mFeatureInfo: VectorFeature_t = VectorFeature_t(), mPointList: gm.GM_Point_t_array = array([Point_t(0, 0), Point_t(0, 1)]),mNumPoints=2, mLineStyle: LineStyle_t = LineStyle_t(), mVertexElevList: gm.float_array = array([1.05, 2.05])) Parameters ___________ mFeatureInfo: VectorFeature_t List of attributes associated with feature (pointer to GM_AttrValueCharPtr_t/GM_AttrValueIntPtr_t array) (Read-Only use the SetAttrList() member function to set new list) mPointList: Point_t List of points that make up the line (global coordinates when getting, native when adding feature) mNumPoints: int (No SDK desciption) mLineStyle: LineStyle_t Line render style (symbol and font) mVertexElevList: float_array Optional list of elevations for each point in line. If present, must have *mNumPoints* values """ # TODO Methods # TODO Check -According to the SDK description, mPointList and mVertexElevList should be a list of Point_t and floats, repectively # TODO Check -mNUmPoints def __init__(self, mFeatureInfo: VectorFeature_t = VectorFeature_t(), mPointList: gm.GM_Point_t_array = array([Point_t(0, 0), Point_t(0, 1)]),mNumPoints=2, mLineStyle: LineStyle_t = LineStyle_t(), mVertexElevList: gm.float_array = array([1.5, 2.25])): super().__init__() # Fields self.mFeatureInfo = mFeatureInfo self.mPointList = mPointList # when setting, use "obj.mPointList = array_var.cast()". Without calling .cast(), it may not always work self.mNumPoints = mNumPoints self.mLineStyle = mLineStyle self.mVertexElevList = mVertexElevList # when setting, use "obj.mVertexElevList = array_var.cast()". Without calling .cast(), it may not always work
[docs]class LineVolumeParams_t(gm.GM_LineVolumeParams_t): """This type is used to provide the parameters for calculating cut-and-fill volumes along a line feature LineVolumeParams_t(mSize: int = 0, mPoints: gm.GM_Point_t_array = array([Point_t(0, 0), Point_t(0, 1)]), mCutHeights: gm.float_array = array([1.00, 2.00]),mNumPoints: int = 2, mCutHeightsAbsolute: bool = False, mCorridorWidth: float = 2.5, mXSpacing: float = 0.0, mYSpacing: float = 0.0) Parameters ____________ mSize: int, uint32 Size of structure mPoints: Point_t_array List of points in line in global coordinate system mCutHeights: float_array Cut heights for each point in meters mNumPoints: int, uint32 Number of points in mPoints and mCutHeights mCutHeightsAbsoluteL bool Are the cut heights in mCutHeights relative to sea level (TRUE) or ground level (FALSE) mCorridorWidth: float Width (i.e. diameter) in meters of corridor around line in which to calculate volume mXSpacing: float Sample spacing in the x direction in global units mYSpacing: float Sample spacing in the y direction in global units """ # TODO Check datatypes of mCutHeights and mPoints (whether they should be arrays or not) def __init__(self, mSize: int = 0, mPoints: gm.GM_Point_t_array = array([Point_t(0, 0), Point_t(0, 1)]), mCutHeights: gm.float_array = array([1.00, 2.00]),mNumPoints: int = 2, mCutHeightsAbsolute: bool = False, mCorridorWidth: float = 2.5, mXSpacing: float = 0.0, mYSpacing: float = 0.0): super().__init__() # Fields self.mSize = mSize self.mPoints = mPoints self.mCutHeights = mCutHeights self.mNumPoints = mNumPoints self.mCutHeightsAbsolute = mCutHeightsAbsolute self.mCorridorWidth = mCorridorWidth self.mXSpacing = mXSpacing self.mYSpacing = mYSpacing
[docs]class MapCatalogInfo_t(gm.GM_MapCatalogInfo_t): """This type represents information about a map catalog. Use GM_GetLayerInfo for more generic information, like bounds. MapCatalogInfo_t(mSize: int = 0, mNumMaps: int =1, mHideBounds: bool = False, mDisplayType = gm.GM_MapCatalog_DisplayTypePercent , mReserved: int = None, mDisplayValue: float = 1.001, mDisplayValue2: float = 2.005) Parameters ___________ mSize: int, uint32 Size of structure mHideBounds: bool Hide layer bounds when not drawing data mDisplayType: GM_MapCatalogDisplayType_t8 Controls when layers in catalog are displayed mDisplayValue: float First value related to display type mDisplayValue2: float Second value for range of scales mNumMaps: int, uint32 mNumber of maps in catalog. mReserved: int, uint8 Reserved for future use, must be 0 """ def __init__(self, mSize: int = 0, mNumMaps: int =1, mHideBounds: bool = False, mDisplayType = gm.GM_MapCatalog_DisplayTypePercent , mReserved: int = None, mDisplayValue: float = 1.001, mDisplayValue2: float = 2.005): super().__init__() self.mSize = mSize self.mNumMaps = mNumMaps self.mHideBounds = mHideBounds self.mDisplayType = mDisplayType #self.mReserved = mReserved self.mDisplayValue = mDisplayValue self.mDisplayValue2 = mDisplayValue2
[docs]class PathProfileLOSParams_t(gm.GM_PathProfileLOSParams_t): """This type is used to provide the parameters for calculating path profiles and performing line of sight analysis PathProfileLOSParams_t(mSize: int, mFlags:int, mStartX: float, mStartY: float, mEndX: float, mEndY: float, mElevList: gm.float_array = array([3.25, 4.125]), mListSize: int = 2, mDfltElev: float = 1, mDetailsStr: str = None, mDetailsStrMaxLen: int = 256, mAtmosphericCorr: float = 1.3333, mLOSFromHeight: float = 1, mLOSToHeight: float = 5,mLOSMinClearance: float = 0.0, mLOSMinClearancePos=Point_t(3, 3), mFresnelFreq: float = 0.0, mFresnelPctClear: float = 0.6, mLOSFirstBlockedPos: Point_t = Point_t(0, 1), mLOSLastBlockedPos: Point_t = Point_t(2, 2)) Parameters _____________ mSize: int, uint32 IN: Size of structure mFlags: GM_PathProfileLOSFlags_t32 IN: Flags controlling behavior mStartX: float IN: Start X coord in current projection mStartY: float IN: Start Y coord in current projection mEndX: float IN: End X coord in current projection mEndY: float IN: End Y coord in current projection mElevList: float_array OUT: List of Elevations. mListSize: int, uint32 IN: Number of elevations to retrieve mDfltElev: float IN: Elev to use when none could be found mDetailsStr: str String containing path details (set to NULL if you don't care) mDetailsStrMaxLen: int, uint32 IN: Maximum length of details string mAtmosphericCorr: float IN: Atmospheric correction for LOS (1.3333 is standard for radio waves, 1.0 is no correction) mLOSFromHeight: float IN: Line-of-sight from height in meters mLOSToHeight: float IN: Line-of-sight to height in meters mLOSMinClearance: float OUT: Minimum line-of-sight clearance in meters (will be negative if the line of sight is not clear) mLOSMinClearancePos: Point_t OUT: Location of minimum line-of-sight clearance mFresnelFreq: float IN: Frequency (in GHz) to use for testing clearance of first Fresnel zone (use 0.0 to not do Fresnel testing) mFresnelPctClear: float IN: Percentage of first Fresnel zone that must be clear of obstacles (use 0.6 for 60%). If 0 is specified, the default of 60% is used. mLOSFirstBlockedPos: Point_t OUT: Location of first blocked location along path (only valid if mLOSMinClearance is negative) mLOSLastBlockedPos: Point_t OUT: Location of last blocked location along path (only valid if mLOSMinClearance is negative) """ def __init__(self, mSize: int=0, mFlags:int=gm.GM_PathProfile_LOSValid, mStartX: float=0, mStartY: float=0, mEndX: float=0, mEndY: float=0, mElevList: gm.float_array = array([3.25, 4.125]), mListSize: int = 2, mDfltElev: float = 1, mDetailsStr: str = None, mDetailsStrMaxLen: int = 256, mAtmosphericCorr: float = 1.3333, mLOSFromHeight: float = 1, mLOSToHeight: float = 5,mLOSMinClearance: float = 0.0, mLOSMinClearancePos=Point_t(3, 3), mFresnelFreq: float = 0.0, mFresnelPctClear: float = 0.6, mLOSFirstBlockedPos: Point_t = Point_t(0, 1), mLOSLastBlockedPos: Point_t = Point_t(2, 2)): super().__init__() self.mSize = mSize self.mFlags = mFlags self.mStartX = mStartX self.mStartY = mStartY self.mEndX = mEndX self.mEndY = mEndY self.mElevList = mElevList # when setting, use "obj.mElevList = array_var.cast()". Without calling .cast(), it may not always work self.mListSize = mListSize self.mDfltElev = mDfltElev self.mDetailsStr = mDetailsStr self.mDetailsStrMaxLen = mDetailsStrMaxLen self.mAtmosphericCorr = mAtmosphericCorr self.mLOSFromHeight = mLOSFromHeight self.mLOSToHeight = mLOSToHeight self.mLOSMinClearance = mLOSMinClearance self.mLOSMinClearancePos = mLOSMinClearancePos self.mFresnelFreq = mFresnelFreq self.mFresnelPctClear = mFresnelPctClear self.mLOSFirstBlockedPos = mLOSFirstBlockedPos self.mLOSLastBlockedPos = mLOSLastBlockedPos
[docs]class PixelRect_t(gm.GM_PixelRect_t): """This type describes a bounding rectangle in pixel coordinates PixelRect_t(mBottom: int = 0, mLeft: int = 0, mRight: int = 0, mTop: int = 0) Parameters ___________ mBottom: int, sint32 Bottom coordinate of rectangle mLeft: int, sint32 Left coordinate of rectangle mRight: int, sint32 Right coordinate of rectangle mTop: int, sint32 Top coordinate of rectangle """ def __init__(self, mLeft: int = 0, mRight: int = 0, mTop: int = 0, mBottom: int = 0): super().__init__() # Fields self.mLeft = mLeft self.mRight = mRight self.mTop = mTop self.mBottom = mBottom
[docs]class Point3D_t(gm.GM_Point3D_t): """Structure for holding a 3D Point Point3D_t(mX: float=0, mY: float=0, mElev: float=0) Parameters ___________ mX: float x coordinate mY: float y coordinate mElev: float Elevation value """ def __init__(self, mX: float = 0, mY: float = 0, mElev: float = 0): super().__init__() self.mX = mX self.mY = mY self.mElev = mElev
[docs]class PointStyle_t(gm.GM_PointStyle_t): """This type is used to describe a style used for drawing a point feature and its label (if any) PointStyle_t(mSymbolName: str='Dot', mFont: FontDef_t = FontDef_t(), mDrawLabel: bool = True, mDrawLabelAlways: bool = True, mRotation: int = 0, mScale: float = -10) Parameters ___________ mSymbolName: str Name of symbol mFont: FontDef_t Font to use to render label mDrawLabel: bool Render the label for this line if there is one mDrawLabelAlways: bool Render the label for this line even if it collides with another display label mRotation: int, uint32 rotation angle in degrees (0 is up/north, 90 right/east, etc.) OR'd with rotation sense flags (GM_RotationSense_t16) mScale: float Symbol scaling factor to apply (use negative values to make symbol a fixed height in meters, i.e. -10 would make symbol 10 meters high) """ # TODO Methods def __init__(self, mSymbolName: str='Dot', mFont: FontDef_t = FontDef_t(), mDrawLabel: bool = True, mDrawLabelAlways: bool = True, mRotation: int = 0, mScale: float = -10): super().__init__() # Fields self.mSymbolName = mSymbolName self.mFont = mFont self.mDrawLabel = mDrawLabel self.mDrawLabelAlways = mDrawLabelAlways self.mRotation = mRotation self.mScale = mScale
# has methods
[docs]class PointFeature_t(gm.GM_PointFeature_t): """A Managed Definition of a Point Feature PointFeature_t(mFeatureInfo: VectorFeature_t = VectorFeature_t(),mPos: Point_t = Point_t(0, 0), mPointStyle: PointStyle_t = PointStyle_t('Default_Point_Style')) Parameters _____________ mFeatureInfo: VectorFeature_t Returns the Feature Info (To update us Various update functions) mPos: Point_t Location of the point (global coordinates when getting, native when adding feature) mPointStyle: PointStyle_t Point render style (symbol and font) (Read-Only use the SetPointStyle() member function to set) """ # TODO Methods def __init__(self, mFeatureInfo: VectorFeature_t = VectorFeature_t(),mPos: Point_t = Point_t(0, 0), mPointStyle: PointStyle_t = PointStyle_t()): super().__init__() self.mFeatureInfo = mFeatureInfo self.mPos = mPos self.mPointStyle = mPointStyle
# Has methods
[docs]class PreTranslateMessageInfo_t(gm.GM_PreTranslateMessageInfo_t): """ PreTranslateMessageInfo_t(mMSG: int = 0, mMsgProcessed: bool=True) """ def __init__(self, mMSG: int = 0, mMsgProcessed: bool = True): super().__init__() self.mMSG = mMSG # TODO: Handled as void*, probably shouldn't be self.mMsgProcessed = mMsgProcessed
[docs]class RasterDisplayOptions_t(gm.GM_RasterDisplayOptions_t): """This type represents the display options available for raster and elevation layers RasterDisplayOptions_t(self, mSize: int=0, mContrastMode: int=gm.GM_Contrast_None, mAutoClipCollar: bool=False, mColorIntensity: int=0, mSamplingMethod: int=gm.GM_SAMPLING_NEAREST_NEIGHBOR, mTextureMap: bool=False, mBlendMode: int=gm.GM_BlendMode_None, mTranslucency: int=512, mTransparent: bool=False, mTransparentColor: int=0xFFFFFFFF, mTransparentColorDist: int=0, mRedAdjustPercent: int=50, mGreenAdjustPercent: int=50, mBlueAdjustPercent: int=50, mBandLayoutValid: bool=False, mBandIdxRed: int=0, mBandIdxGreen: int=0, mBandIdxBlue: int=0, mContrastNumStdDev: int=0, mContrastShared: bool=False, mColorGradeValid: bool=False, mColorGradeRedInMin: int=0, mColorGradeRedInMax: int=0, mColorGradeRedOutMin: int=0, mColorGradeRedOutMax: int=0, mColorGradeBlueInMin: int=0, mColorGradeBlueInMax: int=0, mColorGradeBlueOutMin: int=0, mColorGradeBlueOutMax: int=0, mColorGradeGreenInMin: int=0, mColorGradeGreenInMax: int=0, mColorGradeGreenOutMin: int=0, mColorGradeGreenOutMax: int=0, mColorGradeSaturation: float=0.5, mTransparentColorList: gm.COLORREF_array=gm.COLORREF_array(1)) Parameters _____________ mSize: unit32, int Size mContrastMode: GM_ContrastMode_t8 Contrast adjustment mode mAutoClipCollar: bool Automatically crop off a DRG, BSB, or other known collar boundary mColorIntensity: uint8, int Color intensity (0-20). Lower values are lighter, higher values are darker. mSamplingMethod: GM_SamplingMethod_t8, int Specify how resampling should be done for this layer for display and export mTextureMap: bool Texture map this raster layer over any underlying elevation layers. mBlendMode: GM_BlendMode_t8, int Blend mode to use to blend this raster layer with underlying layers or to interpret the color values of the layer mTranslucency: uint16, int Translucency level of layer (0 - completely see-through, 512 - completely opaque) mTransparent: bool Is layer transparent? mTransparentColor: COLORREF, int Color to make transparent mTransparentColorDist: uint8, int Fuzzy transparency support. Distance from transparent color to treat nearby colors transparent. mRedAdjustPercent: sint8, int Percentage to adjust red color channel by (-100 to 100) mGreenAdjustPercent: sint8, int Percentage to adjust green color channel by (-100 to 100) mBlueAdjustPercent: sint8, int Percentage to adjust blue color channel by (-100 to 100) mBandLayoutValid: bool Are the band layout values valid? mBandIdxRed: uint8, int Index of color band (0-based) to use for red color channel mBandIdxGreen: uint8, int Index of color band (0-based) to use for green color channel mBandIdxBlue: uint8, int Index of color band (0-based) to use for blue color channel mContrastNumStdDev: float (double) Number of standard deviations from mean to stretch for contrast adjustment (if 0 is used the default of 2 will be used) mContrastShared: bool Is the contrast adjustment shared with other loaded layers? mColorGradeValid: bool Are the color grade options valid? mColorGradeRedInMin: uint8, int Minimum red input color value mColorGradeRedInMax: uint8, int Maximum red input color value mColorGradeRedOutMin: uint8, int Minimum red output color value mColorGradeRedOutMax: uint8, int Maximum red output color value mColorGradeBlueInMin: uint8, int Minimum Blue input color value mColorGradeBlueInMax: uint8, int Maximum Blue input color value mColorGradeBlueOutMin: uint8, int Minimum Blue output color value mColorGradeBlueOutMax: uint8, int Maximum Blue output color value mColorGradeGreenInMin: uint8, int Minimum Green input color value mColorGradeGreenInMax: uint8, int Maximum Green input color value mColorGradeGreenOutMin: uint8, int Minimum Green output color value mColorGradeGreenOutMax: uint8, int Maximum Green output color value mColorGradeSaturation: uint8, int Saturation (valid 0.0 - 1.0) mTransparentColorList: COLORREF_array List of colors to make transparent. use set_mTransparentColorList(val) and get_mTransparentColorList() -> GM.COLORREF_array do not set directly. mTransparentColorListSize: Size of mTransparentColorList """ def __init__(self, mSize: int = 0, mContrastMode: int = gm.GM_Contrast_None, mAutoClipCollar: bool = False, mColorIntensity: int = 0, mSamplingMethod: int = gm.GM_SAMPLING_NEAREST_NEIGHBOR, mTextureMap: bool = False, mBlendMode: int = gm.GM_BlendMode_None, mTranslucency: int = 512, mTransparent: bool = False, mTransparentColor: int = 0xFFFFFFFF, mTransparentColorDist: int = 0, mRedAdjustPercent: int = 50, mGreenAdjustPercent: int = 50, mBlueAdjustPercent: int = 50, mBandLayoutValid: bool = False, mBandIdxRed: int = 0, mBandIdxGreen: int = 0, mBandIdxBlue: int = 0, mContrastNumStdDev: float = 0, mContrastShared: bool = False, mColorGradeValid: bool = False, mColorGradeRedInMin: int = 0, mColorGradeRedInMax: int = 0, mColorGradeRedOutMin: int = 0, mColorGradeRedOutMax: int = 0, mColorGradeBlueInMin: int = 0, mColorGradeBlueInMax: int = 0, mColorGradeBlueOutMin: int = 0, mColorGradeBlueOutMax: int = 0, mColorGradeGreenInMin: int = 0, mColorGradeGreenInMax: int = 0, mColorGradeGreenOutMin: int = 0, mColorGradeGreenOutMax: int = 0, mColorGradeSaturation: float = 0.5, mTransparentColorList: gm.COLORREF_array = array([COLORREF(0), COLORREF(1)]), mTransparentColorListSize: int=2): super().__init__() self.mSize = mSize self.mContrastMode = mContrastMode self.mAutoClipCollar = mAutoClipCollar self.mColorIntensity = mColorIntensity self.mSamplingMethod = mSamplingMethod self.mTextureMap = mTextureMap self.mBlendMode = mBlendMode self.mTranslucency = mTranslucency self.mTransparent = mTransparent self.mTransparentColor = mTransparentColor self.mTransparentColorDist = mTransparentColorDist self.mRedAdjustPercent = mRedAdjustPercent self.mGreenAdjustPercent = mGreenAdjustPercent self.mBlueAdjustPercent = mBlueAdjustPercent self.mBandLayoutValid = mBandLayoutValid self.mBandIdxRed = mBandIdxRed self.mBandIdxGreen = mBandIdxGreen self.mBandIdxBlue = mBandIdxBlue self.mContrastNumStdDev = mContrastNumStdDev self.mContrastShared = mContrastShared self.mColorGradeValid = mColorGradeValid self.mColorGradeRedInMin = mColorGradeRedInMin self.mColorGradeRedInMax = mColorGradeRedInMax self.mColorGradeRedOutMin = mColorGradeRedOutMin self.mColorGradeRedOutMax = mColorGradeRedOutMax self.mColorGradeBlueInMin = mColorGradeBlueInMin self.mColorGradeBlueInMax = mColorGradeBlueInMax self.mColorGradeBlueOutMin = mColorGradeBlueOutMin self.mColorGradeBlueOutMax = mColorGradeBlueOutMax self.mColorGradeGreenInMin = mColorGradeGreenInMin self.mColorGradeGreenInMax = mColorGradeGreenInMax self.mColorGradeGreenOutMin = mColorGradeGreenOutMin self.mColorGradeGreenOutMax = mColorGradeGreenOutMax self.mColorGradeSaturation = mColorGradeSaturation self.mTransparentColorList = mTransparentColorList # when setting, use "obj.mTransparentColorList = array_var.cast()". Without calling .cast(), it may not always work self.mTransparentColorListSize = mTransparentColorListSize
[docs]class RasterLayout_t(gm.GM_RasterLayout_t): """This type represents layout information for a new custom raster layer RasterLayout_t(mTopLeft: Point_t, mFlags = gm.GM_RasterLayout_BGROrder, mXPixelSize: float = 1, mYPixelSize: float = 1, mPixelHeight: int = 1080, mPixelWidth: int = 1920, mNumBands: int = 3, mBitsPerBand: int = 8, mBytesPerRow: int = 0, mPalette: COLORREF = None, mPaletteSize: int = 16, mAlphaBandIdx: int = 0) Parameters ______________ mTopLeft: Point_t Ground coordinates of top left corner of the top left pixel mFlags: RasterLayoutFlags_t32 General flags for layout. mXPixelSize: float Size of each pixel in the x direction mYPixelSize float Size of each pixel in the y direction mPixelWidth: int, sint32 Number of pixels in the x direction mPixelHeight: int, sint32 Number of pixels in the y direction mNumBands: int, uint32 Number of bands of data (usually 1 for grayscale or 3 for RGB) mBitsPerBand: int, uint32 Number of bits per band of data (usually 8) mBytesPerRow: int, uint32 Number of bytes per row of data in data buffer. If 0 this will be calculated for you. mPalette: COLORREF Array of colors for palette (set to NULL for no palette) mPaletteSize: int, uint32 Number of colors in palette mAlphaBandIdx: int, uint32 0-based alpha channel band index (usually 0 or 3). Ignored unless GM_RasterLayout_AlphaPresent flag is set. """ def __init__(self, mFlags=gm.GM_RasterLayout_BGROrder, mTopLeft: Point_t = Point_t(0,0), mXPixelSize: float = 1, mYPixelSize: float = 1, mPixelHeight: int = 1080, mPixelWidth: int = 1920, mNumBands: int = 3, mBitsPerBand: int = 8, mBytesPerRow: int = 0, mPalette: COLORREF = None, mPaletteSize: int = 0, mAlphaBandIdx: int = 0): super().__init__() # Fields self.mFlags = mFlags self.mTopLeft = mTopLeft self.mXPixelSize = mXPixelSize self.mYPixelSize = mYPixelSize self.mPixelHeight = mPixelHeight self.mPixelWidth = mPixelWidth self.mNumBands = mNumBands self.mBitsPerBand = mBitsPerBand self.mBytesPerRow = mBytesPerRow self.mPalette = mPalette self.mPaletteSize = mPaletteSize # No SDK decription self.mAlphaBandIdx = mAlphaBandIdx
[docs]class RoughnessGridParams_t(gm.GM_RoughnessGridParams_t): """Structure defining setup for a roughness operation RoughnessGridParams_t(mTable: int=gm.GM_Roughness_CorineSummer, mFlags: int=gm.GM_RoughnessFlags_DisableProgress, mBounds: Rectangle_t:Rectangle_t(), mXSpacing: float=0, mYSpacing: float=0, mDesc: str='Roughness layer_GM_attribute', mCreateAreas: bool=True) Parameters _______________ mTable: GM_RoughnessTable_t, int Table to use for converting color/land cover type to roughness values mFlags: GM_RoughnessGridFlags_t32, int Misc. flags to control operation mBounds: GM.Rectangle_t Bounding rectangle (in specified projection) for roughness grid (pixel-is-area, i.e. provide coordinates of outer edge of sample not center of pixel) mDesc: str Layer description mXSpacing: float Grid cell spacing in X dimension in specified projection coordinates (use 0.0 for default) mYSpacing: float Grid cell spacing in Y dimension in specified projection coordinates (use 0.0 for default) mCreateAreas: bool Create roughness areas. """ def __init__(self, mTable: int = gm.GM_Roughness_CorineSummer, mFlags: int = gm.GM_RoughnessFlags_DisableProgress, mBounds: Rectangle_t = Rectangle_t(), mDesc: str = 'Roughness layer_GM_attribute', mXSpacing: float = 0, mYSpacing: float = 0, mCreateAreas: bool = True): super().__init__() self.mTable = mTable self.mFlags = mFlags self.mBounds = mBounds self.mDesc = mDesc self.mXSpacing = mXSpacing self.mYSpacing = mYSpacing self.mCreateAreas = mCreateAreas
[docs]class RotatedRect_t(gm.GM_RotatedRect_t): """This type defines a rotated rectangle with a ground coordinate at each of 4 corners RotatedRect_t(mTopLeft: Point_t=Point_t(0, 0), mTopRight: Point_t=Point_t(0, 0), mBottomRight: Point_t=Point_t(0, 0), mBottomLeft: Point_t=Point_t(0, 0)) Parameters _____________ mTopLeft: GM_Point_t Top left point mTopRight: GM_Point_t Top right point mBottomRight: GM_Point_t Bottom right point mBottomLeft: GM_Point_t Bottom left point """ def __init__(self, mTopLeft: Point_t = Point_t(0, 0), mTopRight: Point_t = Point_t(0, 0), mBottomRight: Point_t = Point_t(0, 0), mBottomLeft: Point_t = Point_t(0, 0)): super().__init__() self.mTopLeft = mTopLeft self.mTopRight = mTopRight self.mBottomRight = mBottomRight self.mBottomLeft = mBottomLeft
[docs]class ShaderOptions_t(gm.GM_ShaderOptions_t): """This type represents the display options available for the built-in elevation shaders ShaderOptions_t(mSize: int = 0, mDaylightShaderColor: int = 0xFFFFFFFF, mGradientShaderLoColor: int = 0, mGradientShaderHiColor: int = 0xFFFFFFFF, mSlopeShaderMinColor: int = 0, mSlopeShaderMinSlope: float = 0, mSlopeShaderMaxColor: int = 0xFFFFFFFF, mSlopeShaderMaxSlope: float = 0, mHSVShaderLoColorStart: float = 0, mHSVShaderSaturation: float = 0.5, mHSVShaderValue: float = 0.5, mHSVShaderRange: float = 100, mHSVShaderReverse: bool = False, mSlopeShaderCustomValid: bool = True, mReserved = array([0,0], dtype=uint8),mSlopeShaderCustomColor: int = 0xFFFFFFFF) Parameters _____________ mSize: int, uint32 Size of structure mDaylightShaderColor: COLORREF, int Surface color for daylight shader mGradientShaderLoColor: COLORREF, int Min elevation color for gradient shader mGradientShaderHiColor: COLORREF, int Max elevation color for gradient shader mSlopeShaderMinColor: COLORREF, int Min slope color for slope shader mSlopeShaderMinSlope: float Min slope for slope shader in radians mSlopeShaderMaxColor: COLORREF, int Max slope color for slope shader mSlopeShaderMaxSlope: float Max slope for slope shader in radians mHSVShaderLoColorStart: float HSV Shader - Low Color Start in Degrees (0-360) mHSVShaderSaturation: float HSV Shader - Saturation (0-1) mHSVShaderValue: float HSV Shader - Value (0-1) mHSVShaderRange: float HSV Shader - Range (>1) mHSVShaderReverse: bool HSV Shader - Reverse Colors mSlopeShaderCustomValid: bool Is the custom slope shader color valid? mReserved Reserved padding bytes mSlopeShaderCustomColor: COLORREF, int Color to display between min and max slope for slope shader (set mSlopeShaderCustomValid to TRUE to enable) """ def __init__(self, mSize: int = 0, mDaylightShaderColor: int = 0xFFFFFFFF, mGradientShaderLoColor: int = 0, mGradientShaderHiColor: int = 0xFFFFFFFF, mSlopeShaderMinColor: int = 0, mSlopeShaderMinSlope: float = 0, mSlopeShaderMaxColor: int = 0xFFFFFFFF, mSlopeShaderMaxSlope: float = 0, mHSVShaderLoColorStart: float = 0, mHSVShaderSaturation: float = 0.5, mHSVShaderValue: float = 0.5, mHSVShaderRange: float = 100, mHSVShaderReverse: bool = False, mSlopeShaderCustomValid: bool = True, mReserved = array([0,0], dtype=uint8),mSlopeShaderCustomColor: int = 0xFFFFFFFF): super().__init__() self.mSize = mSize self.mDaylightShaderColor = mDaylightShaderColor self.mGradientShaderLoColor = mGradientShaderLoColor self.mGradientShaderHiColor = mGradientShaderHiColor self.mSlopeShaderMinColor = mSlopeShaderMinColor self.mSlopeShaderMinSlope = mSlopeShaderMinSlope self.mSlopeShaderMaxColor = mSlopeShaderMaxColor self.mSlopeShaderMaxSlope = mSlopeShaderMaxSlope self.mHSVShaderLoColorStart = mHSVShaderLoColorStart self.mHSVShaderSaturation = mHSVShaderSaturation self.mHSVShaderValue = mHSVShaderValue self.mHSVShaderRange = mHSVShaderRange self.mHSVShaderReverse = mHSVShaderReverse self.mSlopeShaderCustomValid = mSlopeShaderCustomValid self.mSlopeShaderCustomColor = mSlopeShaderCustomColor self.mReserved = mReserved.cast()
[docs]class ValName_t(gm.GM_ValName_t): """This type is used to describe a value and its associated name Parameters ____________ mVal: int Value mName: str Value name """ def __init__(self, mVal: int, mName: str): super().__init__() # Fields self.mVal = mVal self.mName = mName
[docs]class ViewShedParams_t(gm.GM_ViewShedParams_t): """This type represents the display options available for the built-in elevation shaders ViewShedParams_t(mVectorLayerList, mVectorLayerListCnt, mSize:int = 0, mAngleEnd: float = 6.28319, mAngleStart = 0, mAtmosphericCorr = 1.33, mCenterPoint = Point_t(0, 0), mColor = 0, mDesc = None, mFilterRect = Rectangle_t(), mFresnelFreq = 0.0, mFresnelPctClear = 0.6, mGenCoveragePolys = False, mRadius = 10000, mReceiverAngle = None, mReceiverAngleEnd = None, mReceiverHeight = 5, mReceiverHeightAbs = False, mShowHiddenPoints = False, mShowProgress = True, mTransmitterHeight = 5, mTransmitterHeightAbs = False, mUseEarthCurvature = True, mVectorElevsAbs = False, mXSpacing = 0.0, mYSpacing = 0.0) Parameters ____________ mSize: int, uint32 Size of structure mAngleEnd: float End angle in radians for radar sweep mAngleStart: float Start angle in radians for radar sweep mAtmosphericCorr: float Atmospheric correction value (1.0 for none) mCenterPoint: Point_t Center point in global coordinates mColor: COLORREF Color to display view shed data in mDesc: str View shed description mRadius: float Search radius in meters mReceiverAngle: float Angle (in degrees) above horizon to test at (NULL for none) mReceiverHeight: float Height at which transmitter must be visible mReceiverHeightAbs: float Is the receiver height absolute or relative to the ground? mShowHiddenPoints: bool hidden points visible instead of viewable points. mShowProgress: bool Display view shed calculation progress? mGenCoveragePolys: float Generate area/polygon features for the covered area (these are vector and exportable to vector formats) mTransmitterHeight: float Transmitter height in meters mTransmitterHeightAbs: bool Is the transmitter height absolute or relative to the ground? mUseEarthCurvature: bool Use the curvature of the earth in the analysis? mVectorElevsAbs: bool Are vector elevations absolute (i.e. relative to sea level) or relative to ground level? mVectorLayerList: GM_LayerHandle_t32 List of vector layers to use features with elevation attributes from mVectorLayerListCnt: int, uint32 Number of vector layers in list mXSpacing X: float sample spacing (use 0.0 for default spacing) mYSpacing Y: float sample spacing (use 0.0 for default spacing) mFilterRect: Rectangle_t Optional rectangle for filtering view shed to a certain area of interest mReceiverAngleEnd: float (in degrees) above horizon to stop test at (NULL for none) - if this and mReceiverAngle are provided, an angle range view shed test is done (like a flashlight beam) mFresnelFreq: float Frequency (in GHz) to use for testing clearance of first Fresnel zone (use 0.0 to not do Fresnel testing) mFresnelPctClear: float Percentage of first Fresnel zone that must be clear of obstacles (use 0.6 for 60%). If 0 is specified, the default of 60% is used. """ def __init__(self, mSize: int, mAngleEnd: float, mAngleStart: float, mAtmosphericCorr: float, mCenterPoint: Point_t, mColor: COLORREF = 0, mDesc: str = None, mRadius: float = 10000, mReceiverAngle: gm.double_array = None, mReceiverHeight: float = 5, mReceiverHeightAbs: bool = False, mShowHiddenPoints: bool = False, mShowProgress: bool = True, mGenCoveragePolys: bool = False, mTransmitterHeight: float = 5, mTransmitterHeightAbs: bool = False, mUseEarthCurvature: bool = True, mVectorElevsAbs: bool = False, mVectorLayerList: gm.GM_LayerHandle_array = array([LayerHandle_t(0)]), mVectorLayerListCnt: int = 1, mXSpacing: float = 0.0, mYSpacing: float = 0.0, mFilterRect: Rectangle_t = Rectangle_t(), mReceiverAngleEnd: gm.double_array = None, mFresnelFreq: float = 0.0, mFresnelPctClear: float = 0.6): super().__init__() self.mSize = mSize self.mAngleEnd = mAngleEnd self.mAngleStart = mAngleStart self.mAtmosphericCorr = mAtmosphericCorr self.mCenterPoint = mCenterPoint self.mColor = mColor self.mDesc = mDesc self.mFilterRect = mFilterRect self.mFresnelFreq = mFresnelFreq self.mFresnelPctClear = mFresnelPctClear self.mGenCoveragePolys = mGenCoveragePolys self.mRadius = mRadius self.mReceiverAngle = mReceiverAngle self.mReceiverAngleEnd = mReceiverAngleEnd self.mReceiverHeight = mReceiverHeight self.mReceiverHeightAbs = mReceiverHeightAbs self.mShowHiddenPoints = mShowHiddenPoints self.mShowProgress = mShowProgress self.mTransmitterHeight = mTransmitterHeight self.mTransmitterHeightAbs = mTransmitterHeightAbs self.mUseEarthCurvature = mUseEarthCurvature self.mVectorElevsAbs = mVectorElevsAbs self.mVectorLayerList = mVectorLayerList.cast() # when setting, use "obj.mVectorLayerList = array_var.cast()". Without calling .cast(), it may not always work self.mVectorLayerListCnt = mVectorLayerListCnt self.mXSpacing = mXSpacing self.mYSpacing = mYSpacing
[docs]class WatershedParams_t(gm.GM_WatershedParams_t): """Type defining parameters for watershed/drainage/stream calculation WatershedParams_t(mFlags: int = gm.GM_Watershed_FillGaps, mBounds: Rectangle_t = Rectangle_t(), mDesc: str = 'Watershed layer_GM_attribute', mXSpacing: float = 0.0, mYSpacing: float = 0.0, mFilledDEMFilename: str = "", mMaxDepressionDepth: float = 0.0, mStreamThreshold: int = 2) Parameters ___________ mFlags: GM_WatershedFlags_32, int Flags with misc. options mBounds: Rectangle_t Bounding rectangle (in specified projection) for watershed mDesc: str Layer description mXSpacing: float Grid cell spacing in X dimension in specified projection coordinates (use 0.0 for default) mYSpacing: float Grid cell spacing in Y dimension in specified projection coordinates (use 0.0 for default) mFilledDEMFilename: str Filename to save filled DEM to as a GMG file (typically NULL or empty string) mMaxDepressionDepth: float Maximum depth of depression to fill in meters (0.0 for no depression filling) mStreamThreshold: int, uint32 Drainage threshold for how many cells have to flow to a cell before it is considered part of a stream. """ def __init__(self, mFlags: int = gm.GM_Watershed_FillGaps, mBounds: Rectangle_t = Rectangle_t(), mDesc: str = 'Watershed layer_GM_attribute', mXSpacing: float = 0.0, mYSpacing: float = 0.0, mFilledDEMFilename: str = "", mMaxDepressionDepth: float = 0.0, mStreamThreshold: int = 2): super().__init__() self.mFlags = mFlags self.mBounds = mBounds self.mDesc = mDesc self.mXSpacing = mXSpacing self.mYSpacing = mYSpacing self.mFilledDEMFilename = mFilledDEMFilename self.mMaxDepressionDepth = mMaxDepressionDepth self.mStreamThreshold = mStreamThreshold
[docs]class WebFormatExportOpts_t(gm.GM_WebFormatExportOpts_t): """This type represents the options when exporting to a web format WebFormatExportOpts_t(mMapName: str = "", mMaxZoomLevel: int = 3, mNumZoomLevels: int = 3, mFormat: int = gm.GM_Export_GeoTIFF, mFlags: int = gm.GM_WebExport_NoTransparency, mApiKey: str = "", mBgMapName: str = "", mTranslucency: float = 1.0, mXRes: float = 0.0, mYRes: float = 0.0, mWWTilePath: str = None, mCustomTileFName=None, mMapDescription: str = "", mMapType: str = "baselayer", mTileSize: int = 0) Parameters ____________ mMapName: str Name to use for map set mMaxZoomLevel: int, uint32 Maximum zoom level to export at (Google Maps, Virtual Earth/Bing Maps, and WorldWind exports only) mNumZoomLevels: int, uint32 Number of zoom levels to export (Google Maps, Virtual Earth/Bing Maps, and WorldWind exports only) mFormat: GM_RasterExportFormat_t32, int Image format mFlags: GM_WebExportFlags_t32, int Export flags mApiKey: str API key (used for Google Maps and Bing Maps exports) mBgMapName: str Background map name - used for Google Maps export (ie. ROADMAP, SATELLITE, HYBRID, or TERRAIN) or Bing Maps (i.e. road, aerial, birdseye, canvasDark, canvasLight, or grayscale) mTranslucency: float Translucency setting for new map (0.0 - 1.0). 1.0 is opaque. If 0.0 is provided, it will be assumed to be 1.0. mXRes: float X resolution for export (arc degrees for KML, meters for other, default of 0.0 is full resolution). Used to auto-select mMaxZoomLevel if not provided. mYRes: float Y resolution for export (arc degrees for KML, meters for other, default of 0.0 is full resolution). Used to auto-select mMaxZoomLevel if not provided. mWWTilePath: str Path to where WorldWind tiles should be stored. If NULL the path to the provide XML file will be used mCustomTileFName: str Custom definition for tile filenames. Use NULL for default for format. Use variables like %z for zoom, %x for column, and %y for row. For example, use "%z\\prefix_%y_%x.png" to do one folder per zoom level. The tiles are created in the path under the HTML filename path. mMapDescription: str Description for the map. Currently only used with MBTiles exports. mMapType: str Type of MBTiles map. Must be "baselayer" or "overlay". mTileSize: int, uint32 Pixel size of tile (i.e. 256, 512, 1024, etc.). Value of 0 results in default tile size (usually 256x256) """ def __init__(self, mMapName: str = "", mMaxZoomLevel: int = 3, mNumZoomLevels: int = 3, mFormat: int = gm.GM_Export_GeoTIFF, mFlags: int = gm.GM_WebExport_NoTransparency, mApiKey: str = "", mBgMapName: str = "", mTranslucency: float = 1.0, mXRes: float = 0.0, mYRes: float = 0.0, mWWTilePath: str = None, mCustomTileFName=None, mMapDescription: str = "", mMapType: str = "baselayer", mTileSize: int = 0): super().__init__() self.mMapName = mMapName self.mMaxZoomLevel = mMaxZoomLevel self.mNumZoomLevels = mNumZoomLevels self.mFormat = mFormat self.mFlags = mFlags self.mApiKey = mApiKey self.mBgMapName = mBgMapName self.mTranslucency = mTranslucency self.mXRes = mXRes self.mYRes = mYRes self.mWWTilePath = mWWTilePath # self.mTileCount = mTileCount # since mTileCount is an OUT pointer, it is not useful in python self.mCustomTileFName = mCustomTileFName self.mMapDescription = mMapDescription self.mMapType = mMapType self.mTileSize = mTileSize
[docs]class LidarClassFilter_t(gm.GM_LidarClassFilter_t): # TODO: Broken until fix for uint32 arrays is implemented """Define a filter for Lidar classes with 1 bit for each Lidar class (from 0-255). The first uint32 is for classes 0-31, the next for classes 32-63, etc. Use gm.LidarClassFilter_IsClassEnabled and gm.LidarClassFilter_SetClassEnabled to query or modify which classes are on or off. LidarClassFilter_t(mBitMask: uint32_array=uint32_array([0, 0, 0, 0, 0, 0, 0, 0])) Parameters ______________ mBitMask: uint32_array, len(8) a bit for each LiDAR class. If the bit is 0, the class is enabled. If the bit is 1, the class is disabled. """ def __init__(self, mBitMask: gm.uint32_array=gm.uint32_array(8)): # defaults to allowing all types super().__init__() self.mBitMask = mBitMask
[docs]class LidarClassInfo_t(gm.GM_LidarClassInfo_t): """This type is used to get/set information about Lidar classes LidarClassInfo_t(mClass: int=gm.GM_LidarClass_Unclassified, mClassGroup: int=gm.GM_LidarGroup_Noise, mName: str="", mColor: int=0xFF0000FF) Parameters ________________ mClass: GM_LidarClass_t8, int Classification mClassGroup: GM_LidarClassGroup_t16, int Mask of group(s) the class is in mName: str Classification name (set to NULL to reset to default name in GM_SetLidarClassInfo) mColor: COLORREF, int Color to use for rendering class points """ def __init__(self, mClass: int = gm.GM_LidarClass_Unclassified, mClassGroup: int = gm.GM_LidarGroup_Noise, mName: str = "", mColor: int = 0xFF0000FF): super().__init__() self.mClass = mClass self.mClassGroup = mClassGroup self.mName = mName self.mColor = mColor
# Wrapper for gm exceptions
[docs]class PyGMException(gm.PyGMException): # Static variable dictionary containing error code / error message pairs. # this is a manual copy from https://www.bluemarblegeo.com/knowledgebase/global-mapper-sdk-20/html/T_GlobalMapper_Types_GM_Error_t32.htm # TODO: find way to auto-generate this dictionary, as it will fall out of date otherwise error_message_pairs = { gm.GM_Error_None: "The function completed successfully", gm.GM_Error_InvalidLayer: "The provided layer is not open", gm.GM_Error_InvalidParam: "A parameter was invalid", gm.GM_Error_LoadError: "Unable to load layer", gm.GM_Error_MultipleLayers: "Multiple layers were found in the file being loaded (call GM_LoadLayerList instead)", gm.GM_Error_CollarSetup: "Unable to automatically crop the collar", gm.GM_Error_DrawError: "An unknown error occured drawing the layer(s)", gm.GM_Error_ExportError: "An unknown error occured exporting the layer(s)", gm.GM_Error_NothingToExport: "No data was available to export", gm.GM_Error_InvalidFormat: "An invalid export format was specified", gm.GM_Error_RectifyError: "An error occured rectifying the image", gm.GM_Error_NotSupported: "The operation is not supported for the layer", gm.GM_Error_NotRegistered: "No registry key was found to enable this functionality", gm.GM_Error_NoDataAtLocation: "No data was found at the specified location", gm.GM_Error_OutOfMemory: "Not enough memory to complete the requested operation", gm.GM_Error_Projection: "An error occured projecting a coordinate", gm.GM_Error_NoProjectionSet: "No view/export projection is currently set", gm.GM_Error_ViewShedCalc: "An error occurred performing the view shed analysis", gm.GM_Error_OperationCanceled: "The user canceled the operation", gm.GM_Error_OnlineConnect: "A connection to the online service could not be established", gm.GM_Error_OnlineUnknownSource: "No online source with the theme name provided could be found", gm.GM_Error_GenerateContours: "An error occurred generating the contours", gm.GM_Error_NotRasterLayer: "The layer provided is not a raster or elevation layer", gm.GM_Error_InvalidPackage: "The provided handle is not a valid package", gm.GM_Error_InvalidFeatureIndex: "There was no feature at the given index in the layer", gm.GM_Error_InvalidDrawStyle: "The drawing style passed in is not valid", gm.GM_Error_InvalidSymbolName: "The symbol name provided does not match any available point symbols", gm.GM_Error_SymbolAlreadyCreated: "The symbol name specified has already been added", gm.GM_Error_MissingFile: "The file specified could not be found", gm.GM_Error_GPSDataNotValid: "The GPS data requested does not currently have a valid value available", gm.GM_Error_GPSAlreadyTracking: "A GPS device is already being tracked, call GM_GPSStopTracking", gm.GM_Error_VolumeCalcFailed: "An error occurred calculating the volume", gm.GM_Error_InvalidHoleIndex: "The area does not have a hole at the index provided", gm.GM_Error_InvalidMapIndex: "There is no map at the given index in the map catalog", gm.GM_Error_3DNotOpen: "No 3D view window is currently open", gm.GM_Error_3DLibraryNotFound: "The ExternalViewerIntf.dll library was not found", gm.GM_Error_3DLibraryBadInterface: "The ExternalViewerIntf.dll library did not have the proper interface", gm.GM_Error_3DCreateError: "Unexpected error creating 3D view", gm.GM_Error_3DSetViewError: "Unexpected error setting 3D view", gm.GM_Error_NothingFound: "No features were found within the search area", gm.GM_Error_SearchError: "Unexpected search area", gm.GM_Error_LowMemory: "Some data was not drawn due to low available memory", gm.GM_Error_NotElevationLayer: "The layer provided is not an elevation layer", gm.GM_Error_FileAlreadyInCatalog: "The provided file was already in the map catalog to which it was being added.", gm.GM_Error_TypeAlreadyExists: "The provided type name was already used by an existing type", gm.GM_Error_DatumAlreadyExists: "A built-in datum with the given name already exists", gm.GM_Error_UnknownEllipsoid: "The ellipsoid name provided does not match a known ellipsoid", gm.GM_Error_GridError: "Error generating grid from 3D vector data", gm.GM_Error_InvalidShaderName: "The shader name provided was not found", gm.GM_Error_SymbolNotCustom: "The symbol name provided is not a custom one that can be deleted", gm.GM_Error_MGRSParseError: "Error parsing MGRS coordinate string", gm.GM_Error_CreateBufferError: "Error creating a buffer around a feature", gm.GM_Error_CopyrightedData: "The data attempting to be exported or fetched is copyrighted", gm.GM_Error_BrushAlreadyCreated: "A fill style with the provided name already exists", gm.GM_Error_BrushError: "An error was encountered adding the custom fill brush", gm.GM_Error_EllipsoidAlreadyExists: "An ellipsoid with the given name already exists", gm.GM_Error_CombineError: "An error occurred combining the areas", gm.GM_Error_SkippedEmpty: "Empty tile was skipped on export due to passing GM_ExportFlags_SkipEmpty", gm.GM_Error_NoFeatureElev: "The feature does not have a single elevation value (for lines and areas there may be per-vertex values)", gm.GM_Error_ArcGISNotLicensed: "Attempted to load an ArcGIS database, but there is no license for ArcGIS", gm.GM_Error_NotSupportedIn64BitBuild: "Attempted to use functionality that is not supported in a 64-bit build", gm.GM_Error_UnableToConnectToDB: "Unable to connect to the database using the input connection string", gm.GM_Error_Unspecified: "Generic unspecified error", gm.GM_Error_Script: "Error running script", gm.GM_Error_InvalidLidarPointIdx: "The Lidar point index is out of range", gm.GM_Error_NothingChanged: "Nothing was changed by the modification", gm.GM_Error_NotPaletteLayer: "The layer is not a palette-based layer", gm.GM_Error_NotImageLayer: "The layer does not contain color imagery", gm.GM_Error_InvalidBand: "The provided band was outside the range of bands for the layer", gm.GM_Error_NoElevationLayersLoaded: "There are no elevation layers currently loaded", gm.GM_Error_NoVectorLayersLoaded: "There are no vector layers currently loaded", gm.GM_Error_COAST: "Unspecified COAST processing error", gm.GM_Error_NoCOASTModelParmsLoaded: "No model parameter file is loaded", gm.GM_Error_RegistryOpFailed: "Error while reading or writing the registry", gm.GM_Error_InvalidCodePage: "The code page provided is not known", gm.GM_Error_InvalidLidarQuery: "The Lidar query that you passed in is not an active one", gm.GM_Error_LidarPointInQuery: "The Lidar point was already in the Lidar query", gm.GM_Error_LidarPointNotInQuery: "The Lidar point was not found in the Lidar query", gm.GM_Error_NumCodes: "Number of Error Codes Defined", gm.GM_Error_NotImplemented: "The given function hasn't been implemented yet", gm.GM_Error_TerraServerConnect: "A connection to the TerraService could not be established"#, #gm.GM_Error_TerraServerBadTheme: "No TerraServer theme with the theme name provided could be found" } def __init__(self, _code: int, _message: str = ""): super().__init__() # if no specific message is passed, pull the message from the error message dict if _message == "": if _code in PyGMException.error_message_pairs.keys(): _message = PyGMException.error_message_pairs[_code] else: # if the error message is not found in the dict, attempt fo find and raise the error name itself as the message for a in dir(gm): if a.startswith('GM_Error_') and _code == gm.__getattribute__(a): _message = str(a) self.code = _code self.message = _message def __str__(self): return str(self.code) + ': ' + self.message
[docs]class LidarStats_t(gm.GM_LidarStats_t): """Definition of statistics for a Lidar point cloud LidarStats_t(mAllPointsStats: LidarReturnInfo_t = LidarReturnInfo_t(), mAttrStats: gm.GM_LidarAttrInfo_array = gm.GM_LidarAttrInfo_array(1), mClassStats: gm.GM_LidarReturnInfo_array = gm.GM_LidarReturnInfo_array(1), mReturnStats: gm.GM_LidarReturnInfo_array = gm.GM_LidarReturnInfo_array(1), mAvgElev: float = 0, mStdDevElev: float = 0, mAvgIntensity: float = 0, mStdDevIntensity: float = 0) Parameters ______________ mAllPointsStats: LidarReturnInfo_t Statistics for everything together mAttrStats: LidarAttrInfo_array Statistics by attribute mClassStats: LidarReturnInfo_array Statistics by class mReturnStats: LidarReturnInfo_array Statistics by return type mAvgElev: float Average of elevation values mStdDevElev: float Average of intensity values mAvgIntensity: float Standard deviation of elevation values mStdDevIntensity: float Standard deviation of intensity values """ pass def __init__(self, mAllPointsStats: LidarReturnInfo_t = LidarReturnInfo_t(), mAttrStats: gm.GM_LidarAttrInfo_array = gm.GM_LidarAttrInfo_array(1), mClassStats: gm.GM_LidarReturnInfo_array = gm.GM_LidarReturnInfo_array(1), mReturnStats: gm.GM_LidarReturnInfo_array = gm.GM_LidarReturnInfo_array(1), mAvgElev: float = 0, mStdDevElev: float = 0, mAvgIntensity: float = 0, mStdDevIntensity: float = 0): super().__init__() self.mAllPointsStats = mAllPointsStats self.mAttrStats = mAttrStats self.mClassStats = mClassStats self.mReturnStats = mReturnStats self.mAvgElev = mAvgElev self.mStdDevElev = mStdDevElev self.mAvgIntensity = mAvgIntensity self.mStdDevIntensity = mStdDevIntensity
[docs]class LidarQueryFilter_t(gm.GM_LidarQueryFilter_t): # TODO: Broken until fix for uint32 arrays is implemented """Definition of Lidar query filter. LidarQueryFilter_t(mSize: int=0, mClassFilter: LidarClassFilter_t=LidarClassFilter_t(), mColorDist: int=0, mColorsToKeep: gm.COLORREF_array=None, mFilterFlags: int=0, mElevMaxValidM: float=0.0, mElevMinValidM: float=0.0, mHeightMaxValidM: float=0.0, mHeightMinValidM: float=0.0, mIntensityMin: int=0, mIntensityMax: int=0, mKeepFirstRetIfNoDelta: bool=False, mNdviMaxValid: float=0.0, mNdviMinValid: float=0.0, mNdviRangeValid: bool=True, mNdwiMaxValid: float=0.0, mNdwiMinValid: float=0.0, mPointSourceIdList: gm.uint32_array=gm.uint32_array(1), mReturnHeightMaxAngle: int=0, mReturnHeightMaxValidM: float=0, mReturnHeightMinValidM: float=0, mReturnHeightMinKeepAllReturnCount: int=0, mReturnMask: int=0, mScanAngleMax: float=0, mScanAngleMin: float=0, mScanAngleValid: bool=True, mDensityMax: float=0, mDensityMin: float=0, mDensityRangeValid: bool=True) Parameters _____________ mClassFilter: LidarClassFilter_t Classification filter (zero'd out means all enabled) mColorDist: int Maximum color "distance" to search when using mColorsToKeep mColorsToKeep: COLORREF_array Optional list of colors to keep (NULL to not filter by color) mColorsToKeepCount: int Size of mColorsToKeep mFilterFlags: GM_LidarFilterFlags_t32, int Mask of filter flags to check. Default of 0 doesn't check any flags. mElevMaxValidM: float Maximum elevation to keep (meters). Use GM_INVALID_ELEV_VALUE for none. mElevMinValidM: float Minimum elevation to keep (meters). Use GM_INVALID_ELEV_VALUE for none. mHeightMaxValidM: float Maximum height above ground to keep (meters). Use GM_INVALID_ELEV_VALUE for none. mHeightMinValidM: float Minimum height above ground to keep (meters). Use GM_INVALID_ELEV_VALUE for none. mIntensityMax: int Maximum intensity to keep mIntensityMin: int Minimum intensity to keep mKeepFirstRetIfNoDelta: bool Keep first returns if the return height delta is 0 (use for files with missing last returns - Bug 15754) mNdviMaxValid: float Maximum valid NDVI value (Range[-1,+1]) mNdviMinValid: float Minimum valid NDVI value (Range[-1,+1]) mNdviRangeValid: bool Should we check the NDVI (requires NIR channel)? mNdwiMaxValid: float Maximum valid NDWI value (Range[-1,+1]) mNdwiMinValid: float Minimum valid NDWI value (Range[-1,+1]) mNdwiRangeValid: bool Should we check the NDWI? mPointSourceIdList: uint32_array List of point source IDs to keep (NULL to not filter by point source ID) mPointSourceIdListCount: int Size of mPointSourceIdList mReturnHeightMaxAngle: int Maximum gradient angle in degrees between first and last point to filter out if return height outside of allowed range. mReturnHeightMaxValidM: int Maximum return height delta to keep (meters) mReturnHeightMinValidM: int Minimum return height delta to keep (meters) mReturnHeightMinKeepAllReturnCount: bool If filtering to a return height range, minimum number of returns to have to keep and ignore the max angle mReturnMask: int List of return masks to keep mScanAngleMax: float Maximum scan angle (degrees) to keep mScanAngleMin: float Minimum scan angle (degrees) to keep mScanAngleValid: bool Is the scan angle range filter valid? mDensityMax: float Max density to keep in points / m^2 mDensityMin: float Min density to keep in points / m^2 mDensityRangeValid: bool Should we filter by density range? """ def __init__(self, mClassFilter: LidarClassFilter_t = LidarClassFilter_t(), mColorDist: int = 0, mColorsToKeep: gm.COLORREF_array = None, mColorsToKeepCount: int=0, mTransparentColorListSize: int=0, mFilterFlags: int = 0, mElevMaxValidM: float = 0.0, mElevMinValidM: float = 0.0, mHeightMaxValidM: float = 0.0, mHeightMinValidM: float = 0.0, mIntensityMin: int = 0, mIntensityMax: int = 0, mKeepFirstRetIfNoDelta: bool = False, mNdviMaxValid: float = 0.0, mNdviMinValid: float = 0.0, mNdviRangeValid: bool = True, mNdwiMaxValid: float = 0.0, mNdwiMinValid: float = 0.0, mNdwiRangeValid: bool = True, mPointSourceIdList: gm.uint32_array = None, mPointSourceIdListCount: int=1, mReturnHeightMaxAngle: int = 0, mReturnHeightMaxValidM: float = 0, mReturnHeightMinValidM: float = 0, mReturnHeightMinKeepAllReturnCount: int = 0, mReturnMask: int = 0, mScanAngleMax: float = 0, mScanAngleMin: float = 0, mScanAngleValid: bool = True, mDensityMax: float = 0, mDensityMin: float = 0, mDensityRangeValid: bool = True): super().__init__() self.mClassFilter = mClassFilter self.mColorDist = mColorDist self.mColorsToKeep = mColorsToKeep self.mColorsToKeepCount = mColorsToKeepCount self.mTransparentColorListSize = mTransparentColorListSize self.mFilterFlags = mFilterFlags self.mElevMaxValidM = mElevMaxValidM self.mElevMinValidM = mElevMinValidM self.mHeightMaxValidM = mHeightMaxValidM self.mHeightMinValidM = mHeightMinValidM self.mIntensityMin = mIntensityMin self.mIntensityMax = mIntensityMax self.mKeepFirstRetIfNoDelta = mKeepFirstRetIfNoDelta self.mNdviMaxValid = mNdviMaxValid self.mNdviMinValid = mNdviMinValid self.mNdviRangeValid = mNdviRangeValid self.mNdwiMaxValid = mNdwiMaxValid self.mNdwiMinValid = mNdwiMinValid self.mNdwiRangeValid = mNdwiRangeValid self.mPointSourceIdList = mPointSourceIdList # when setting, use "obj.mPointSourceIdList = array_var.cast()". Without calling .cast(), it may not always work self.mPointSourceIdListCount = mPointSourceIdListCount self.mReturnHeightMaxAngle = mReturnHeightMaxAngle self.mReturnHeightMaxValidM = mReturnHeightMaxValidM self.mReturnHeightMinValidM = mReturnHeightMinValidM self.mReturnHeightMinKeepAllReturnCount = mReturnHeightMinKeepAllReturnCount self.mReturnMask = mReturnMask self.mScanAngleMax = mScanAngleMax self.mScanAngleMin = mScanAngleMin self.mScanAngleValid = mScanAngleValid self.mDensityMax = mDensityMax self.mDensityMin = mDensityMin self.mDensityRangeValid = mDensityRangeValid
[docs]class LidarQueryInfo_t(gm.GM_LidarQueryInfo_t): # TODO: Wait for LayerHandle_array fix """Define structure to hold information about a Lidar query LidarQueryInfo_t(mNumPoints: int = 0, mLayerList: gm.GM_LayerHandle_array = None, mLayerCount: int=0) Parameters _____________ mNumPoints: int Total number of points in query mLayerList: LayerHandle_array List of layers that have points in query mLayerCount: int Size of mLayerList """ def __init__(self, mNumPoints: int = 0, mLayerList: gm.GM_LayerHandle_array = None, mLayerCount: int=0): super().__init__() self.mNumPoints = mNumPoints self.mLayerList = mLayerList # when setting, use "obj.mLayerList = array_var.cast()". Without calling .cast(), it may not always work self.mLayerCount = mLayerCount
[docs]class ProjDef_t(gm.GM_ProjDef_t): """This type is used to fully describe a projection. ProjDef_t(mDefinition: Projection_t=Projection_t(), mWKT: str="") Parameters ________________ mDefinition: Projection_t The projection to use mWKT: str the WellKnownText """ def __init__(self, mDefinition: Projection_t = Projection_t(), mWKT: str = ""): super().__init__() self.mDefinition = mDefinition self.mWKT = mWKT
[docs]class VerticalDisplayOptions_t(gm.GM_VerticalDisplayOptions_t): """Structure with options controlling the display of terrain data VerticalDisplayOptions_t(mShaderName: str = "", mAmbientLight: float = 1.0, mVertExag: float = 1.0, mLightAltitude: float = 45.0, mLightAzimuth: float = 180.0, mHillShading: bool = True, mWaterEnabled: bool = True, mWaterAlpha: int = 128, mWaterColorRed: int = 0, mWaterColorGrn: int = 0, mWaterColorBlue: int = 255, mWaterLevel: float = 0, mShadeDarkness: int = 0, mShadeHighlight: int = 0, mSlopeAlgorithm: int = gm.GM_SlopeAlg_Combined4, mLightBlendingAlgorithm: int = gm.GM_BLENDING_ALG_AVERAGE, mLightNumSources: int = 1) Parameters _____________ mShaderName: str Shader name mAmbientLight: float Ambient light level (Range: 0.0 - 1.0) mVertExag: float Vertical exaggeration (Range: 0.1 - 10.0) mLightAltitude: float Light altitude (Range: 0.0 - 90.0) mLightAzimuth: float Light azimuth (Range: 0.0 - 360.0) mHillShading: bool Is hill shading enabled? mWaterEnabled: bool Is Water display enabled? mWaterAlpha: int Alpha translucency of water (Range: 0 - 255) mWaterColorRed: int Water color - red component mWaterColorGrn: int Water color - green component mWaterColorBlue: int Water color - blue component mWaterLevel: float Water level (meters) mShadeDarkness: int Maximum hill shader shadow darkness (0 - 255, 0 is black, 255 is white) mShadeHighlight: int Highlight level (whiteness) to apply for direct sunlight (0 is no additional whiteness, and 255 is completely white) mSlopeAlgorithm: GM_SlopeAlg_t8, int Slope calculation algorithm mLightBlendingAlgorithm: GM_ShaderBlendingAlg_t8, int Algorithm used to blend intensity when using multiple light sources mLightNumSources: int Number of light sources (Range: 1 - 360) """ def __init__(self, mShaderName: str = "", mAmbientLight: float = 1.0, mVertExag: float = 1.0, mLightAltitude: float = 45.0, mLightAzimuth: float = 180.0, mHillShading: bool = True, mWaterEnabled: bool = True, mWaterAlpha: int = 128, mWaterColorRed: int = 0, mWaterColorGrn: int = 0, mWaterColorBlue: int = 255, mWaterLevel: float = 0, mShadeDarkness: int = 0, mShadeHighlight: int = 0, mSlopeAlgorithm: int = gm.GM_SlopeAlg_Combined4, mLightBlendingAlgorithm: int = gm.GM_BLENDING_ALG_AVERAGE, mLightNumSources: int = 1): super().__init__() self.mShaderName = mShaderName self.mAmbientLight = mAmbientLight self.mVertExag = mVertExag self.mLightAltitude = mLightAltitude self.mLightAzimuth = mLightAzimuth self.mHillShading = mHillShading self.mWaterEnabled = mWaterEnabled self.mWaterAlpha = mWaterAlpha self.mWaterColorRed = mWaterColorRed self.mWaterColorGrn = mWaterColorGrn self.mWaterColorBlue = mWaterColorBlue self.mWaterLevel = mWaterLevel self.mShadeDarkness = mShadeDarkness self.mShadeHighlight = mShadeHighlight self.mSlopeAlgorithm = mSlopeAlgorithm self.mLightBlendingAlgorithm = mLightBlendingAlgorithm self.mLightNumSources = mLightNumSources
# # Custom re-definition CombineTerrainLayers(aSetup, aReserved) #
[docs]def CombineTerrainLayers(aSetup): """Combines two loaded terrain layers using some operation and creates a new terrain layer from the combined return. The returned new layer must be closed with GM_CloseLayer when you are done working with it. """ ok, res = gm.CombineTerrainLayers(aSetup, 0) if ok != gm.GM_Error_None: raise Exception(f"FAILED: {PyGMException(ok)}") return res
[docs]def GenerateElevationGrid(aLayerList, aGridSetup): r"""Generates an elevation grid and optionally a 3D area TIN layer from loaded 3D vector data. The layer handle(s) returned in <aGridLayer> and (optionally) <aTinLayer> must be closed with CloseLayer when you are done with them. """ ok, dem, tin = gm.GenerateElevationGrid(aLayerList, aGridSetup) if ok != gm.GM_Error_None: raise Exception(f"FAILED: {PyGMException(ok)}") return dem
if __name__ == '__main__': print("import me")