Types for Lidar Functions ========================= The following types are used as parameters and return values in the various Lidar operations within GlobalMapper. These types use fixed, numeric constants, which are defined here. ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarAttr_t8 Different Lidar attribute types that can have their values retrieved :values: **GM_LidarAttr_ReturnNo** = 0 **GM_LidarAttr_Intensity** = 1 **GM_LidarAttr_Class** = 2 **GM_LidarAttr_ScanAngle** = 3 **GM_LidarAttr_UserData** = 4 **GM_LidarAttr_PointSource** = 5 **GM_LidarAttr_NumTypes** = 6 ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarClass_t8 ASPRS Lidar types :values: **GM_LidarClass_NeverClassified** = 0 **GM_LidarClass_Unclassified** = 1 **GM_LidarClass_Ground** = 2 **GM_LidarClass_LowVeg** = 3 **GM_LidarClass_MedVeg** = 4 **GM_LidarClass_HighVeg** = 5 **GM_LidarClass_Building** = 6 **GM_LidarClass_LowPoint** = 7 low point (noise) **GM_LidarClass_ModelKeyPoint** = 8 thinned ground (model key points) **GM_LidarClass_Water** = 9 **GM_LidarClass_Railroad** = 10 IMPORTANT NOTE: USGS used to use this as Overlap to DO NOT treat as ground. **GM_LidarClass_Road** = 11 Road Surface **GM_LidarClass_Overlap** = 12 **GM_LidarClass_WireGuard** = 13 Wire - Guard (Shield) **GM_LidarClass_WireConductor** = 14 Wire - Conductor (Phase) **GM_LidarClass_TransmissionTower** = 15 Transmission Tower **GM_LidarClass_WireStructureConnector** = 16 Wire-structure Connector (e.g. Insulator) **GM_LidarClass_Bridge** = 17 Bridge deck **GM_LidarClass_HighNoise** = 18 High Noise point **GM_LidarClass_OverheadStructure** = 19 Overhead structure **GM_LidarClass_IgnoredGround** = 20 Ignored Ground (typically breakline proximity) **GM_LidarClass_Snow** = 21 If present and identifiable *Topo-Bathy Lidar profile types* **GM_LidarClass_BathyPoint** = 40 **GM_LidarClass_WaterSurface** = 41 **GM_LidarClass_DerivedWaterSurface** = 42 **GM_LidarClass_SubmergedObject** = 43 **GM_LidarClass_IhoS57Object** = 44 **GM_LidarClass_NoBottomFoundBathyPoint** = 45 **GM_LidarClass_MaxValid** = 255 ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarClassGroup_t16 Lidar class groups to categorize what type(s) of data a classification represents :values: **GM_LidarGroup_Surface** = 0x0001 Surface points (i.e. ground, water, road) **GM_LidarGroup_OffSurface** = 0x0002 Points that are definitely not on the surface **GM_LidarGroup_Noise** = 0x0004 Noise points **GM_LidarGroup_Powerline** = 0x0008 Points that are along a powerline **GM_LidarGroup_Structure** = 0x0010 Points that are part of a solid structure (i.e. building) **GM_LidarGroup_Vegetation** = 0x0020 Vegetation points **GM_LidarGroup_Bathy** = 0x0040 Bathymetric (i.e. below water surface) points **GM_LidarGroup_Unclassified** = 0x0080 Unclassified points ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarDrawMode_t8 Drawing types for Lidar data :values: **GM_LidarDraw_ElevWColor** = 0 Color based on sample color if available, otherwise elevation **GM_LidarDraw_Elev** = 1 Color based on elevation **GM_LidarDraw_Intensity** = 2 Color based on intensity **GM_LidarDraw_Class** = 3 Color based on class **GM_LidarDraw_Return** = 4 Color based on return (1st, 2nd, etc.) **GM_LidarDraw_HeightAboveGround** = 5 Color based on height above ground **GM_LidarDraw_PointSourceId** = 6 Color based on point source ID **GM_LidarDraw_PointIndex** = 7 Color based on point index **GM_LidarDraw_ReturnHeightDelta** = 8 Color based on difference in height between first and last return of multi-return set **GM_LidarDraw_CIR** = 9 Color infrared display using NIR/red/green for the RGB layout **GM_LidarDraw_NDVI** = 10 Color NDVI value calculated from NIR and red band **GM_LidarDraw_NDWI** = 11 Color NDWI value calculated from NIR and green band **GM_LidarDraw_Density** = 12 Color based on point density **GM_LidarDraw_Withheld** = 13 Color based on withheld flag **GM_LidarDraw_ModelKeyPoint** = 14 Color based on model key point flag **GM_LidarDraw_Overlap** = 15 Color based on overlap point flag **GM_LidarDraw_ScanAngle** = 16 Color based on scan angle **GM_LidarDraw_ByLayer** = 17 Color each layer a different color **GM_LidarDraw_SegmentId** = 18 Color based on segment ID **GM_LidarDraw_NumTypes** = 19 Number of available drawing types **GM_LidarDraw_Default** = GM_LidarDraw_ElevWColor Default setting is coloring by elevation **GM_LidarDraw_Multiple** = 0xFE Multiple different draw modes are select **GM_LidarDraw_UseGlobal** = 0xFF Use global draw mode setting ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarFieldMask_t32 Bit masks of Lidar fields that are to be updated :values: **GM_LidarField_Class** = 0x00000001 Classification is valid **GM_LidarField_Color** = 0x00000002 Color fields are valid **GM_LidarField_XY** = 0x00000004 XY fields are valid **GM_LidarField_Z** = 0x00000008 Z field is valid **GM_LidarField_Intensity** = 0x00000010 Intensity field is valid **GM_LidarField_KeyPoint** = 0x00000020 Key point flag is valid **GM_LidarField_Overlap** = 0x00000040 Overlap flag is valid **GM_LidarField_Synthetic** = 0x00000080 Synthetic flag is valid **GM_LidarField_Withheld** = 0x00000100 Withheld flag is valid **GM_LidarField_Deleted** = 0x00000200 Deleted flag is valid **GM_LidarField_GroundHeight** = 0x00000400 Height above ground is valid **GM_LidarField_ReturnHeight** = 0x00000800 Return height delta is valid **GM_LidarField_NIR** = 0x00001000 NIR fields are valid **GM_LidarField_ReturnNum** = 0x00002000 Return number field is valid **GM_LidarField_ReturnCount** = 0x00004000 Return count field is valid **GM_LidarField_ScanAngle** = 0x00008000 Scan angle field is valid **GM_LidarField_ScannerChannel** = 0x00010000 Scanner channel field is valid **GM_LidarField_SourceID** = 0x00020000 Point source ID field is valid **GM_LidarField_UserData** = 0x00040000 User data field is valid **GM_LidarField_EdgeFlightLine** = 0x00080000 Edge of flight line field is valid **GM_LidarField_SegmentID** = 0x00100000 Segment ID field is valid **GM_LidarFieldMask_All** = 0xFFFFFFFF All fields are valid *Mask of fields that are used during Lidar statistics calculation* **GM_LidarFieldMask_NonStats** = ( _LidarField_Color | GM_LidarField_XY | GM_LidarField_SegmentID | GM_LidarField_NIR ) **GM_LidarFieldMask_Stats** = ~GM_LidarFieldMask_NonStats ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarFilterFlags_t32 Point flags to keep for filter. Each flag has both a bit to say whether it should be used and another to say if it should be on or off. :values: **GM_LidarFilterFlag_WithheldValid** = 0x00000001 Check the withheld flag **GM_LidarFilterFlag_Withheld** = 0x00000002 Point is withheld **GM_LidarFilterFlag_KeyPointValid** = 0x00000004 Check the key point flag **GM_LidarFilterFlag_KeyPoint** = 0x00000008 Point is key point **GM_LidarFilterFlag_OverlapValid** = 0x00000010 Check the overlap flag **GM_LidarFilterFlag_Overlap** = 0x00000020 Point is overlap **GM_LidarFilterFlag_SyntheticValid** = 0x00000040 Check the synthetic flag **GM_LidarFilterFlag_Synthetic** = 0x00000080 Point is synthetic **GM_LidarFilterFlag_DeletedValid** = 0x00000100 Check the deleted flag **GM_LidarFilterFlag_Deleted** = 0x00000200 Point is deleted **GM_LidarFilterFlag_ModifiedValid** = 0x00000400 Check the modified flag **GM_LidarFilterFlag_Modified** = 0x00000800 Point has been modified **GM_LidarFilterFlag_EdgeofFlightLineValid** = 0x00001000 Check the edge of flight flag **GM_LidarFilterFlag_EdgeofFlightLine** = 0x00002000 Point is edge of flight **GM_LidarFilterFlag_ScanDirectionValid** = 0x00004000 Check the scan direction flag **GM_LidarFilterFlag_ScanDirection** = 0x00008000 Point is positive scan direction **GM_LidarFilterFlag_NoneValid** = 0x00010000 Check the none flag **GM_LidarFilterFlag_None** = 0x00020000 Point has no flags set ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarFlags_t32 Flags for Lidar point features :values: **GM_LidarFlags_ColorValid** = 0x00000001 Are the red, green, and blue color values valid? **GM_LidarFlags_Withheld** = 0x00000002 Is the point withheld? **GM_LidarFlags_Synthetic** = 0x00000004 Is the point synthetic? **GM_LidarFlags_KeyPoint** = 0x00000008 Is the point a key point? **GM_LidarFlags_Overlap** = 0x00000010 Is the point overlap? **GM_LidarFlags_ScanDir** = 0x00000020 Scan direction **GM_LidarFlags_EdgeOfFlightLine** = 0x00000040 Is the point on the edge of the flight line **GM_LidarFlags_Deleted** = 0x00000080 Is the point marked as deleted **GM_LidarFlags_Modified** = 0x00000100 Has the point been modified since load? **GM_LidarFlags_NirValid** = 0x00000200 Is the NIR (near infrared) value valid? ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarFlagType_t8 Definition of different types that can be returned :values: **GM_LidarFlag_Synthetic** = 0 **GM_LidarFlag_KeyPoint** = 1 **GM_LidarFlag_Overlay** = 2 **GM_LidarFlag_Withheld** = 3 **GM_LidarFlag_EdgeOfFlightLine** = 4 **GM_LidarFlag_None** = 5 **GM_LidarFlag_NumTypes** = 6 ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarGridField_t8 Fields of data to grid for Lidar data :values: **GM_LidarGrid_Elevation** = 0 Grid the elevation values **GM_LidarGrid_Intensity** = 1 Grid Lidar point intensity values rather than elevation values **GM_LidarGrid_Height** = 2 Grid Lidar height above ground rather than elevation values **GM_LidarGrid_ColorRGB** = 3 Grid the RGB color from Lidar points **GM_LidarGrid_ColorRGBI_NIR** = 4 Grid the RGBI color from 4-band Lidar (RGB+NIR) **GM_LidarGrid_ColorRGBI_Intensity** = 5 Grid the RGBI color from 4-band Lidar (RGB+Intensity) **GM_LidarGrid_Class** = 6 Grid the classification code from Lidar points **GM_LidarGrid_Density** = 7 Grid the point density in points / m^2 of a Lidar point cloud **GM_LidarGrid_NDVI** = 8 Grid the calculated NDVI value from 4-band Lidar (RGB+NIR) **GM_LidarGrid_NDWI** = 9 Grid the calculated NDWI value from 4-band Lidar (RGB+NIR) **GM_LidarGrid_Red** = 10 Grid the Red value (single band) **GM_LidarGrid_Green** = 11 Grid the Green value (single band) **GM_LidarGrid_Blue** = 12 Grid the Blue value (single band) **GM_LidarGrid_NIR** = 13 Grid the NIR value (single band) **GM_LidarGrid_ScanAngle** = 14 Grid the Scan Angle value **GM_LidarGrid_PointSourceID** = 15 Grid the Point Source ID value **GM_LidarGrid_UserData** = 16 Grid the User Data value **GM_LidarGrid_ScannerChannel** = 17 Grid the Scanner Channel value **GM_LidarGrid_NumPointsInCell** = 18 Grid the number of points in each cell **GM_LidarGrid_NumTypes** = 19 ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarReturnPulseId_t8 Enumeration specifying how pulses in a multi-return are identified. They must be contiguous (i.e. by GPS time), but can also skip over things with different fields, like user data or point source ID :values: **GM_LidarPulseId_OnlyGpsTime** = 0 Only the sequence/GPS time is considered **GM_LidarPulseId_UserData** = 1 Points must have appropriate GPS time and same user data to be part of same return **GM_LidarPulseId_PointSourceID** = 2 Points must have appropriate GPS time and same point source ID to be part of same return **GM_LidarPulseId_ScannerChannel** = 3 Points must have appropriate GPS time and same scanner channel to be part of same return **GM_LidarPulseId_PointSourceID_ScannerChannel** = 4 Points must have appropriate GPS time and same point source ID and scanner channel to be part of same return **GM_LidarPulseId_PointSourceID_UserData** = 5 Points must have appropriate GPS time and same point source ID and user data to be part of same return **GM_LidarPulseId_NumTypes** = 6 Number of different values **GM_LidarPulseId_Default** = GM_LidarPulseId_OnlyGpsTime ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarReturnType_t8 Different Lidar point return types :values: **GM_LidarReturn_Unknown** = 0 **GM_LidarReturn_First** = 1 **GM_LidarReturn_Second** = 2 **GM_LidarReturn_Last** = 3 **GM_LidarReturn_Single** = 4 **GM_LidarReturn_FirstOfMany** = 5 **GM_LidarReturn_SecondOfMany** = 6 **GM_LidarReturn_ThirdOrLaterOfMany** = 7 Return number >= 3 **GM_LidarReturn_LastOfMany** = 8 **GM_LidarReturn_NumTypes** = 9 Types for backwards code compatibility **GM_LidarReturn_ThirdOfMany** = GM_LidarReturn_ThirdOrLaterOfMany Return number >= 3 ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarResMult_t Lidar resolution multiplier types for dialog :values: **GM_LidarResMult_Spacings** = 0 Resolution multiplier in spacings **GM_LidarResMult_Meters** = 1 Resolution multiplier in meters **GM_LidarResMult_Feet** = 2 Resolution multiplier in feet **GM_LidarResMult_NumTypes** = 3 ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarClassifyTypes_t32 Flags for types of points to classify :values: **GM_Classify_Ground** = 0x00000001 Classify likely ground points **GM_Classify_Buildings** = 0x00000002 Classify building points **GM_Classify_HighVeg** = 0x00000004 Classify high veg **GM_Classify_Powerline** = 0x00000008 Classify powerlines **GM_Classify_HighNoise** = 0x00000010 Classify high noise **GM_Classify_LowNoise** = 0x00000020 Classify low noise **GM_Classify_Pole** = 0x00000040 Classify pole like objects *Masks of combinations of classifications* **GM_Classify_Noise** = GM_Classify_HighNoise | GM_Classify_LowNoise, **GM_Classify_NonGround** = GM_Classify_Buildings | GM_Classify_HighVeg | GM_Classify_Powerline | GM_Classify_Pole, **GM_Classify_NonGroundDialog** = GM_Classify_Buildings | GM_Classify_HighVeg, **GM_Classify_PoleDialog** = GM_Classify_Powerline | GM_Classify_Pole ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_ClassifyGroundFlags_t32 Flags for ground setup :values: **GM_ClassifyGround_ResetGroundPoints** = 0x00000001 Reset existing ground points to unknown classification at start of operation **GM_ClassifyGround_KeepNonGroundPoints** = 0x00000002 Keep non-ground points as whatever type they were re-classified to rather than resetting **GM_ClassifyGround_CreateDebugLayers** = 0x00000004 Create layers for debugging auto-classify ground **GM_ClassifyGround_RemoveNearNonGround** = 0x00000008 Run the 'remove near non-ground' part of the algorithm **GM_ClassifyGround_HideProgress** = 0x00000010 Don't show cancellable progress during this operation ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_ClassifyNoiseFlags_t32 Flags for noise setup :values: **GM_ClassifyNoise_UnclassifiedOnly** = 0x00000001 Only mark unclassified points as noise **GM_ClassifyNoise_NoHighNoise** = 0x00000002 Don't mark high noise **GM_ClassifyNoise_NoLowNoise** = 0x00000004 Don't mark low noise **GM_ClassifyNoise_CreateDebugLayers** = 0x00000008 Create layers for debugging auto-classify **GM_ClassifyNoise_ChangeClass** = 0x00000010 Change the classification of noise points? **GM_ClassifyNoise_MarkWithheld** = 0x00000020 Mark points as withheld **GM_ClassifyNoise_MarkDeleted** = 0x00000040 Mark points as deleted **GM_ClassifyNoise_ResetNoisePoints** = 0x00000080 Reset existing noise points to unknown classification at start of operation **GM_ClassifyNoise_CheckHeightRange** = 0x00000100 Set if the min/max height above ground range is valid **GM_ClassifyNoise_HideProgress** = 0x00000200 Don't show cancellable progress **GM_ClassifyNoise_Defaults** = GM_ClassifyNoise_ChangeClass Default value ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_ClassifyNonGroundFlags_t32 Flags for non-ground setup :values: **GM_Classify_ResetPoints** = 0x00000001 Reset existing points of the type(s) that are about to be classified **GM_Classify_CreateDebugLayers** = 0x00000002 Create layers for debugging auto-classify with best-fit plane information **GM_Classify_SinglePassBestFit** = 0x00000004 Only do a single pass for the best-fit plane finding rather than doing a 2nd weighted pass **GM_Classify_IgnoreNDVI** = 0x00000008 Don't use the NDVI values for NIR-enabled points to help classify vegetation/buildings **GM_Classify_IgnoreNDWI** = 0x00000010 Don't use the NDWI values for NIR-enabled points to help classify vegetation/buildings **GM_Classify_HideProgress** = 0x00000020 Don't show cancellable progress ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarExtractType_t32 Types of features to extract :values: **GM_LidarExtract_Buildings** = 0x0000001 Extract building outlines **GM_LidarExtract_Trees** = 0x0000002 Extract tree points/areas **GM_LidarExtract_Powerlines** = 0x0000004 Extract powerlines **GM_LidarExtract_Poles** = 0x0000008 Extract poles ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarExtractFlags_t32 Flags for non-ground setup :values: **GM_LidarExtract_CreateSideWalls** = 0x00000001 Create side walls for 3D building outlines **GM_LidarExtract_SaveDebugInfo** = 0x00000002 Save any debug layers **GM_LidarExtract_CreateSeparateRoofPieces** = 0x00000004 Create separate roof pieces if the angle or plane height changes dramatically instead of one building per cluster **GM_LidarExtract_CreateTreePolygons** = 0x00000008 Extract tree coverage areas **GM_LidarExtract_SmoothTreePolygons** = 0x00000010 Smooth the tree coverage area polygons **GM_LidarExtract_BestFitPlaneForRoofPieces** = 0x00000020 If creating separate roof pieces, use a best fit plane of the roof points to get the elevations to assign rather than nearest point **GM_LidarExtract_CreateBuildingAsMesh** = 0x00000040 Create 3D model (mesh) for buildings rather than 3D areas **GM_LidarExtract_CreateFootprints** = 0x00000080 Create footprints **GM_LidarExtract_HideProgress** = 0x00000100 Hide progress dialog ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarExtractLayer_t32 Available layers for Lidar extraction :values: **GM_LidarExtractLayer_BuildingHulls** = 0 Layer for building hulls (3d RDTs) **GM_LidarExtractLayer_BuildingFootprints** = 1 Layer for building footprints (2D RDTs simplified) **GM_LidarExtractLayer_BuildingWalls** = 2 Layer for building walls connecting simplified footprints and roof planes **GM_LidarExtractLayer_BuildingPlanes** = 3 Layer for building planes (boundaries match walls and simplified footprints in x,y) **GM_LidarExtractLayer_Pole** = 4 Layer for pole features **GM_LidarExtractLayer_Powerline** = 5 Layer for powerline features **GM_LidarExtractLayer_Tree** = 6 Layer for tree features **GM_LidarExtract_NumLayers** = 7 ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_CameraModel_t8 Available camera types :values: **GM_CameraModel_Pinhole** = 1 **GM_CameraModel_PinholeRadial1** = 2 **GM_CameraModel_PinholeRadial3** = 3 **GM_CameraModel_PinholeBrown2** = 4 **GM_CameraModel_PinholeSimpleFisheye** = 5 **GM_CameraModel_FirstGap** = 6 **GM_CameraModel_Spherical** = 7 **GM_CameraModel_Default** = GM_CameraModel_PinholeRadial3 **GM_CameraModel_Unknown** = 0 ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_SfmMethod_t8 The various SfM (Structure-from-Motion) methods available :values: **GM_SfmMethod_Incremental** = 0 Incremental2 SfM engine from latest OpenMVG version **GM_SfmMethod_Global** = 1 Global SfM **GM_SfmMethod_GlobalThenInc** = 2 Run Global SfM, then Incremental2 (faster than just doing Incremental2) **GM_SfmMethod_IncrementalOrig** = 3 Original Incremental method from latest OpenMVG version **GM_SfmMethod_IncrementalOld** = 4 Old original Incremental from pre-OpenMVG 1.4 **GM_SfmMethod_NumTypes** = 5 **GM_SfmMethod_Default** = GM_SfmMethod_Incremental ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_SfmQuality_t8 SfM (Structure-from-Motion) quality options :values: **GM_SfmQuality_Normal** = 0 **GM_SfmQuality_High** = 1 **GM_SfmQuality_Ultra** = 2 **GM_SfmQuality_NumTypes** = 3 **GM_SfmQuality_Default** = GM_SfmQuality_Normal ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_SfmImageDescriberMethod_t8 Image describer methods :values: **GM_Describer_SIFT** = 0 Use SIFT method (default) **GM_Describer_AkazeFloat** = 1 Use AKAZE with floating point descriptors **GM_Describer_AkazeMldb** = 2 Use AKAZE with binary descriptors **GM_Describer_NumTypes** = 3 Count of describer methods **GM_Describer_Default** = GM_Describer_SIFT ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_SfmInitializer_t8 Incremental SfM (Structure-from-Motion) initializer methods :values: **GM_SfmInit_ExistingPose** = 0 Initialize the reconstruction from the existing sfm_data camera poses **GM_SfmInit_MaxPair** = 1 Initialize the reconstruction from the pair that has the most of matches **GM_SfmInit_AutoPair** = 2 Initialize the reconstruction with a pair selected automatically **GM_SfmInit_Stellar** = 3 Initialize the reconstruction with a 'stellar' reconstruction **GM_SfmInit_NumTypes** = 4 Count of SFM enumerated values **GM_SfmInit_Default** = GM_SfmInit_Stellar Stellar reconstruction is used as the default parameter value **GM_SfmInit_UseDefault** = -1 Use whatever the default is ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_SfmTriMethod_t8 Incremental SfM triangulation method (enum values must match what is passed to OpenMVG_main_IncrementalSfM2.exe :values: **GM_SfmTriMethod_DirectLinearTransform** = 0 **GM_SfmTriMethod_L1Angular** = 1 **GM_SfmTriMethod_LInfinityAngular** = 2 **GM_SfmTriMethod_InverseDepthWeightedMidpoint** = 3 **GM_SfmTriMethod_NumTypes** = 4 **GM_SfmTriMethod_Default** = GM_SfmTriMethod_InverseDepthWeightedMidpoint **GM_SfmTriMethod_UseDefault** = -1 ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_SfmResection_t8 Incremental SfM Resection method; enum values must match what is passed to OpenMVG_main_IncrementalSfM2.exe :values: **GM_SfmResection_DirectLinearTransform** = 0 **GM_SfmResection_P3P_KE_CVPR17** = 1 **GM_SfmResection_P3P_KNEIP_CVPR11** = 2 **GM_SfmResection_P3P_NORDBERG_ECCV18** = 3 **GM_SfmResection_UP2P_KUKELOVA_ACCV10** = 4 **GM_SfmResection_NumTypes** = 5 **GM_SfmResection_Default** = GM_SfmResection_P3P_NORDBERG_ECCV18 **GM_SfmResection_UseDefault** = -1 ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_GeoRegistrationOrderFlags_t8 How control points and/or GPS EXIF information from the images should be applied :values: **GM_GeoRegistration_GCPsBeforeSfM** = 0x01 Apply Ground Control Points (GCPs) before doing SfM **GM_GeoRegistration_NoExifIfGCPs** = 0x02 Don't apply EXIF information if GCPs are successfully applied **GM_GeoRegistration_GCPsBeforeExif** = 0x04 Apply GCPs before EXIF rather than after **GM_GeoRegistration_UseRobustReg** = 0x08 Use robust registration of EXIF location by default rather than using all points **GM_GeoRegistration_DefaultFlags** = 0 Don't use any of the above options ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_P2PFlags_t32 Option flags for a Pixels-to-Points (P2P) setup object :values: **GM_P2P_AdjustZUsingControlPoints** = 0x00000001 Adjust the Z level using the control points, which should get an even better Z match with this approach **GM_P2P_DeleteWorkFiles** = 0x00000002 Delete the files when finished **GM_P2P_KeepWorkFilesOnSuccess** = 0x00000004 Keep work files on success even if GM_P2P_DeleteWorkFiles is set. Use if you will delete work folder externally **GM_P2P_IgnoreExif** = 0x00000008 Drop the EXIF data in the images **GM_P2P_UseRelativeAltitudes** = 0x00000010 Use relative altitudes offset by a base instead of EXIF values **GM_P2P_UseColorHarmonization** = 0x00000020 Harmonize colors between images before processing **GM_P2P_CloudCreateFromMesh** = 0x00000040 Create point cloud from mesh rather than using original densified cloud. This takes longer but produces point clouds with less 'thickness' **GM_P2P_AddCloudLayer** = 0x00000080 Automatically load and add the cloud layer, even if not saving to a file **GM_P2P_LoadSparseCloud** = 0x00000100 Load the sparse point cloud, in addition to the dense one **GM_P2P_UseSceneClustering** = 0x00000200 Use scene clustering to break up very large jobs **GM_P2P_ImageCreateFromMesh** = 0x00000400 Create an ortho-image from the mesh rather than a point cloud **GM_P2P_ImageCreateSeparate** = 0x00000800 Create a separate ortho-image from each separate image rather than combining them **GM_P2P_DensifyUseSemiGlobal** = 0x00001000 Use semi-global matching for DensifyPointCloud **GM_P2P_HideProgress** = 0x00002000 Don't show a progress dialog for this operation **GM_P2P_RecursiveImageSearch** = 0x00004000 Recursively look for images in mImageFolder ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_SpatialThinAlg_t8 Spatial thinning algorithm; specify which point to select from each bin grid when thinning :values: **GM_ThinAlg_Min** = 0 Use point with minimum elevation in bin **GM_ThinAlg_Max** = 1 Use point with maximum elevation in bin **GM_ThinAlg_Med** = 2 Use point with median elevation in bin **GM_ThinAlg_3D** = 3 Keep median point in each 3D cube of bin size **GM_ThinAlg_KeepNth** = 4 Keep every Nth point (i.e. every 4th return) **GM_ThinAlg_SkipNth** = 5 Skip every Nth point (i.e. skip every 4th return - thin by 25%) **GM_ThinAlg_NumTypes** = 6 Count of thinning algorithms ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarCompareFlags_t32 Lidar comparison flags :values: **GM_LidarCompare_CheckOutsideBounds** = 0x00000001 Include points outside the intersected bounds of both clouds in the changed results **GM_LidarCompare_CompareBothDirs** = 0x00000002 Find points in 'compare to' cloud set that aren't in the 'compare' set, as well as the reverse **GM_LidarCompare_DelNewPoints** = 0x00000004 Mark new points as deleted in their original point cloud layer **GM_LidarCompare_CreateNewLayers** = 0x00000008 Create new point cloud layers with the difference points (if any are found) **GM_LidarCompare_CreateNewQueries** = 0x00000010 Save queries with the difference points from the provided loaded point cloud layer(s) **GM_LidarCompare_HideProgress** = 0x00000020 Hide progress bar dialog **GM_LidarCompare_Default** = GM_LidarCompare_CreateNewLayers Default settings are to create new difference layers ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarColorizeFields_t8 Flags for fields to colorize during the LidarColorize operation :values: **GM_LidarColorize_RGB** = 0 Update RGB fields **GM_LidarColorize_RGBI** = 1 Update RGB+NIR fields **GM_LidarColorize_Inten** = 2 Update Intensity fields **GM_LidarColorize_NumFields** = 3 Count of field flags ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarColorizeFlags_t8 Colorize field types :values: **GM_LidarColorize_OverwriteExisting** = 0x01 Overwrite existing color/intensity values **GM_LidarColorize_Keep8BitValues** = 0x02 Keep values at 8-bit rather than normalizing to 16-bit **GM_LidarColorize_HideProgress** = 0x04 Don't show progress for the operation **GM_LidarColorize_DefaultFlags** = GM_LidarColorize_OverwriteExisting The default setting is to overwrite the existing values ------------------------------------------------------------------------------------------------------------------------ .. py:data:: globalmapper.GM_LidarColorizeIntensity_t8 Colorize operation intensity types :values: **GM_LidarColorizeInten_Gray** = 0 Use grayscale or average value **GM_LidarColorizeInten_Red** = 1 Use red band for intensity **GM_LidarColorizeInten_Green** = 2 Use green band for intensity **GM_LidarColorizeInten_Blue** = 3 Use blue band for intensity **GM_LidarColorizeInten_NumTypes** = 4 Count of intensity band types **GM_LidarColorizeInten_Default** = GM_LidarColorizeInten_Gray Default value is grayscale