three.MF.V3.Settings.Align 

  1from enum import Enum
  2from typing import List
  3
  4
  5class Align:
  6
  7    """
  8     Alignment settings.
  9    """
 10    class Points:
 11
 12        """
 13         Point pair alignment settings.
 14        """
 15        def __init__(self, points: List[float] = None, absoluteError: float = None, relativeError: float = None, useAllPoints: bool = None):
 16            # The set of corresponding point pairs.
 17            self.points = points
 18            # The maximum absolute error for a point pair to be an inlier to the model.
 19            self.absoluteError = absoluteError
 20            # The maximum error relative to the size of the aligned scans for a point pair to be an inlier to the model.
 21            self.relativeError = relativeError
 22            # Ignore alignment errors and use all selected points for alignment.
 23            self.useAllPoints = useAllPoints
 24
 25    class Ransac:
 26
 27        """
 28         Ransac alignment settings.
 29        """
 30        def __init__(self, downsampleVoxelSize: float = None, maximumFeatureRadius: float = None, maximumFeaturePointCount: int = None, maximumMatchDistance: float = None, minimumMatchSimilarity: float = None, mutualFilter: bool = None):
 31            self.downsampleVoxelSize = downsampleVoxelSize
 32            self.maximumFeatureRadius = maximumFeatureRadius
 33            self.maximumFeaturePointCount = maximumFeaturePointCount
 34            self.maximumMatchDistance = maximumMatchDistance
 35            self.minimumMatchSimilarity = minimumMatchSimilarity
 36            self.mutualFilter = mutualFilter
 37
 38    class ICP:
 39
 40        """
 41         Iterative closest point alignment settings.
 42        """
 43        def __init__(self, matchDistance: float):
 44            # The maximum distance for two points to be considered a match.
 45            self.matchDistance = matchDistance
 46
 47    class Rough:
 48
 49        """
 50         Rough alignment settings.
 51        """
 52        class Method(Enum):
 53
 54            """
 55             Rough alignment methods.
 56            """
 57            Empty = "None"  # No rough alignment.
 58            FastGlobal = "FastGlobal"  # Fast global alignment.
 59            Ransac = "Ransac"  # Ransac alignment.
 60            Points = "Points"  # Point pair alignment.
 61
 62        def __init__(self, method: 'Method', ransac: 'Align.Ransac' = None, points: 'Align.Points' = None):
 63            # Rough alignment method.
 64            self.method = method
 65            # FastGlobal fastGlobal;
 66            self.ransac = ransac
 67            # Point pair alignment settings.
 68            self.points = points
 69
 70    class Fine:
 71
 72        """
 73         Fine alignment settings.
 74        """
 75        class Method(Enum):
 76
 77            """
 78             Fine alignment methods.
 79            """
 80            Empty = "None"  # No fine alignment.
 81            ICP = "ICP"  # Iterative closest point alignment.
 82
 83        class Transform:
 84            def __init__(self, rotation: List[float] = None, translation: List[float] = None):
 85                self.rotation = rotation
 86                self.translation = translation
 87
 88        def __init__(self, method: 'Method', icp: 'Align.ICP' = None, initialTransform: 'Transform' = None):
 89            # Fine alignment method.
 90            self.method = method
 91            # Iterative closest point settings.
 92            self.icp = icp
 93            # The initial transform for fine alignment.
 94            self.initialTransform = initialTransform
 95
 96    def __init__(self, source: int, target: int, rough: 'Rough' = None, fine: 'Fine' = None):
 97        # Index of the scan or group to align.
 98        self.source = source
 99        # Index of the scan or group to align to.
100        self.target = target
101        # Rough alignment settings.
102        self.rough = rough
103        # Fine alignment settings.
104        self.fine = fine
class Align: 
  6class Align:
  7
  8    """
  9     Alignment settings.
 10    """
 11    class Points:
 12
 13        """
 14         Point pair alignment settings.
 15        """
 16        def __init__(self, points: List[float] = None, absoluteError: float = None, relativeError: float = None, useAllPoints: bool = None):
 17            # The set of corresponding point pairs.
 18            self.points = points
 19            # The maximum absolute error for a point pair to be an inlier to the model.
 20            self.absoluteError = absoluteError
 21            # The maximum error relative to the size of the aligned scans for a point pair to be an inlier to the model.
 22            self.relativeError = relativeError
 23            # Ignore alignment errors and use all selected points for alignment.
 24            self.useAllPoints = useAllPoints
 25
 26    class Ransac:
 27
 28        """
 29         Ransac alignment settings.
 30        """
 31        def __init__(self, downsampleVoxelSize: float = None, maximumFeatureRadius: float = None, maximumFeaturePointCount: int = None, maximumMatchDistance: float = None, minimumMatchSimilarity: float = None, mutualFilter: bool = None):
 32            self.downsampleVoxelSize = downsampleVoxelSize
 33            self.maximumFeatureRadius = maximumFeatureRadius
 34            self.maximumFeaturePointCount = maximumFeaturePointCount
 35            self.maximumMatchDistance = maximumMatchDistance
 36            self.minimumMatchSimilarity = minimumMatchSimilarity
 37            self.mutualFilter = mutualFilter
 38
 39    class ICP:
 40
 41        """
 42         Iterative closest point alignment settings.
 43        """
 44        def __init__(self, matchDistance: float):
 45            # The maximum distance for two points to be considered a match.
 46            self.matchDistance = matchDistance
 47
 48    class Rough:
 49
 50        """
 51         Rough alignment settings.
 52        """
 53        class Method(Enum):
 54
 55            """
 56             Rough alignment methods.
 57            """
 58            Empty = "None"  # No rough alignment.
 59            FastGlobal = "FastGlobal"  # Fast global alignment.
 60            Ransac = "Ransac"  # Ransac alignment.
 61            Points = "Points"  # Point pair alignment.
 62
 63        def __init__(self, method: 'Method', ransac: 'Align.Ransac' = None, points: 'Align.Points' = None):
 64            # Rough alignment method.
 65            self.method = method
 66            # FastGlobal fastGlobal;
 67            self.ransac = ransac
 68            # Point pair alignment settings.
 69            self.points = points
 70
 71    class Fine:
 72
 73        """
 74         Fine alignment settings.
 75        """
 76        class Method(Enum):
 77
 78            """
 79             Fine alignment methods.
 80            """
 81            Empty = "None"  # No fine alignment.
 82            ICP = "ICP"  # Iterative closest point alignment.
 83
 84        class Transform:
 85            def __init__(self, rotation: List[float] = None, translation: List[float] = None):
 86                self.rotation = rotation
 87                self.translation = translation
 88
 89        def __init__(self, method: 'Method', icp: 'Align.ICP' = None, initialTransform: 'Transform' = None):
 90            # Fine alignment method.
 91            self.method = method
 92            # Iterative closest point settings.
 93            self.icp = icp
 94            # The initial transform for fine alignment.
 95            self.initialTransform = initialTransform
 96
 97    def __init__(self, source: int, target: int, rough: 'Rough' = None, fine: 'Fine' = None):
 98        # Index of the scan or group to align.
 99        self.source = source
100        # Index of the scan or group to align to.
101        self.target = target
102        # Rough alignment settings.
103        self.rough = rough
104        # Fine alignment settings.
105        self.fine = fine

Alignment settings.

Align( source: int, target: int, rough: Align.Rough = None, fine: Align.Fine = None) 
 97    def __init__(self, source: int, target: int, rough: 'Rough' = None, fine: 'Fine' = None):
 98        # Index of the scan or group to align.
 99        self.source = source
100        # Index of the scan or group to align to.
101        self.target = target
102        # Rough alignment settings.
103        self.rough = rough
104        # Fine alignment settings.
105        self.fine = fine
source
target
rough
fine
class Align.Points: 
11    class Points:
12
13        """
14         Point pair alignment settings.
15        """
16        def __init__(self, points: List[float] = None, absoluteError: float = None, relativeError: float = None, useAllPoints: bool = None):
17            # The set of corresponding point pairs.
18            self.points = points
19            # The maximum absolute error for a point pair to be an inlier to the model.
20            self.absoluteError = absoluteError
21            # The maximum error relative to the size of the aligned scans for a point pair to be an inlier to the model.
22            self.relativeError = relativeError
23            # Ignore alignment errors and use all selected points for alignment.
24            self.useAllPoints = useAllPoints

Point pair alignment settings.

Align.Points( points: List[float] = None, absoluteError: float = None, relativeError: float = None, useAllPoints: bool = None) 
16        def __init__(self, points: List[float] = None, absoluteError: float = None, relativeError: float = None, useAllPoints: bool = None):
17            # The set of corresponding point pairs.
18            self.points = points
19            # The maximum absolute error for a point pair to be an inlier to the model.
20            self.absoluteError = absoluteError
21            # The maximum error relative to the size of the aligned scans for a point pair to be an inlier to the model.
22            self.relativeError = relativeError
23            # Ignore alignment errors and use all selected points for alignment.
24            self.useAllPoints = useAllPoints
points
absoluteError
relativeError
useAllPoints
class Align.Ransac: 
26    class Ransac:
27
28        """
29         Ransac alignment settings.
30        """
31        def __init__(self, downsampleVoxelSize: float = None, maximumFeatureRadius: float = None, maximumFeaturePointCount: int = None, maximumMatchDistance: float = None, minimumMatchSimilarity: float = None, mutualFilter: bool = None):
32            self.downsampleVoxelSize = downsampleVoxelSize
33            self.maximumFeatureRadius = maximumFeatureRadius
34            self.maximumFeaturePointCount = maximumFeaturePointCount
35            self.maximumMatchDistance = maximumMatchDistance
36            self.minimumMatchSimilarity = minimumMatchSimilarity
37            self.mutualFilter = mutualFilter

Ransac alignment settings.

Align.Ransac( downsampleVoxelSize: float = None, maximumFeatureRadius: float = None, maximumFeaturePointCount: int = None, maximumMatchDistance: float = None, minimumMatchSimilarity: float = None, mutualFilter: bool = None) 
31        def __init__(self, downsampleVoxelSize: float = None, maximumFeatureRadius: float = None, maximumFeaturePointCount: int = None, maximumMatchDistance: float = None, minimumMatchSimilarity: float = None, mutualFilter: bool = None):
32            self.downsampleVoxelSize = downsampleVoxelSize
33            self.maximumFeatureRadius = maximumFeatureRadius
34            self.maximumFeaturePointCount = maximumFeaturePointCount
35            self.maximumMatchDistance = maximumMatchDistance
36            self.minimumMatchSimilarity = minimumMatchSimilarity
37            self.mutualFilter = mutualFilter
downsampleVoxelSize
maximumFeatureRadius
maximumFeaturePointCount
maximumMatchDistance
minimumMatchSimilarity
mutualFilter
class Align.ICP: 
39    class ICP:
40
41        """
42         Iterative closest point alignment settings.
43        """
44        def __init__(self, matchDistance: float):
45            # The maximum distance for two points to be considered a match.
46            self.matchDistance = matchDistance

Iterative closest point alignment settings.

Align.ICP(matchDistance: float) 
44        def __init__(self, matchDistance: float):
45            # The maximum distance for two points to be considered a match.
46            self.matchDistance = matchDistance
matchDistance
class Align.Rough: 
48    class Rough:
49
50        """
51         Rough alignment settings.
52        """
53        class Method(Enum):
54
55            """
56             Rough alignment methods.
57            """
58            Empty = "None"  # No rough alignment.
59            FastGlobal = "FastGlobal"  # Fast global alignment.
60            Ransac = "Ransac"  # Ransac alignment.
61            Points = "Points"  # Point pair alignment.
62
63        def __init__(self, method: 'Method', ransac: 'Align.Ransac' = None, points: 'Align.Points' = None):
64            # Rough alignment method.
65            self.method = method
66            # FastGlobal fastGlobal;
67            self.ransac = ransac
68            # Point pair alignment settings.
69            self.points = points

Rough alignment settings.

Align.Rough( method: Align.Rough.Method, ransac: Align.Ransac = None, points: Align.Points = None) 
63        def __init__(self, method: 'Method', ransac: 'Align.Ransac' = None, points: 'Align.Points' = None):
64            # Rough alignment method.
65            self.method = method
66            # FastGlobal fastGlobal;
67            self.ransac = ransac
68            # Point pair alignment settings.
69            self.points = points
method
ransac
points
class Align.Rough.Method(enum.Enum): 
53        class Method(Enum):
54
55            """
56             Rough alignment methods.
57            """
58            Empty = "None"  # No rough alignment.
59            FastGlobal = "FastGlobal"  # Fast global alignment.
60            Ransac = "Ransac"  # Ransac alignment.
61            Points = "Points"  # Point pair alignment.

Rough alignment methods.

Empty = <Method.Empty: 'None'>
FastGlobal = <Method.FastGlobal: 'FastGlobal'>
Ransac = <Method.Ransac: 'Ransac'>
Points = <Method.Points: 'Points'>
class Align.Fine: 
71    class Fine:
72
73        """
74         Fine alignment settings.
75        """
76        class Method(Enum):
77
78            """
79             Fine alignment methods.
80            """
81            Empty = "None"  # No fine alignment.
82            ICP = "ICP"  # Iterative closest point alignment.
83
84        class Transform:
85            def __init__(self, rotation: List[float] = None, translation: List[float] = None):
86                self.rotation = rotation
87                self.translation = translation
88
89        def __init__(self, method: 'Method', icp: 'Align.ICP' = None, initialTransform: 'Transform' = None):
90            # Fine alignment method.
91            self.method = method
92            # Iterative closest point settings.
93            self.icp = icp
94            # The initial transform for fine alignment.
95            self.initialTransform = initialTransform

Fine alignment settings.

Align.Fine( method: Align.Fine.Method, icp: Align.ICP = None, initialTransform: Align.Fine.Transform = None) 
89        def __init__(self, method: 'Method', icp: 'Align.ICP' = None, initialTransform: 'Transform' = None):
90            # Fine alignment method.
91            self.method = method
92            # Iterative closest point settings.
93            self.icp = icp
94            # The initial transform for fine alignment.
95            self.initialTransform = initialTransform
method
icp
initialTransform
class Align.Fine.Method(enum.Enum): 
76        class Method(Enum):
77
78            """
79             Fine alignment methods.
80            """
81            Empty = "None"  # No fine alignment.
82            ICP = "ICP"  # Iterative closest point alignment.

Fine alignment methods.

Empty = <Method.Empty: 'None'>
ICP = <Method.ICP: 'ICP'>
class Align.Fine.Transform: 
84        class Transform:
85            def __init__(self, rotation: List[float] = None, translation: List[float] = None):
86                self.rotation = rotation
87                self.translation = translation
Align.Fine.Transform(rotation: List[float] = None, translation: List[float] = None) 
85            def __init__(self, rotation: List[float] = None, translation: List[float] = None):
86                self.rotation = rotation
87                self.translation = translation
rotation
translation