pyRANSAC-3D

https://leomariga.github.io/pyRANSAC-3D/
Admin
pyRANSAC-3D is an open source implementation of Random sample consensus (RANSAC) method that fits...
Tokens:5,523
Snippets:64
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install pyRANSAC-3D

Source: https://leomariga.github.io/pyRANSAC-3D

Install the pyRANSAC-3D library using pip. Ensure you have Numpy installed as a prerequisite.

```bash
pip3 install pyransac3d

```

--------------------------------

### Cuboid Fit Method

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/cuboid

Finds the best plane equations for a cuboid using RANSAC. Requires a 3D point cloud and optional RANSAC parameters.

```python
 | fit(pts, thresh=0.05, maxIteration=5000)

```

--------------------------------

### Plane Class Constructor

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/plane

Initializes the Plane object. No arguments are required for instantiation.

```python
class Plane():
 |  Plane()
```

--------------------------------

### Fit a Plane using RANSAC

Source: https://leomariga.github.io/pyRANSAC-3D

Use the Plane class to fit a plane to a point cloud. Load your point cloud data into a numpy array of shape (N, 3). The fit method returns the plane equation and the inlier points.

```python
import pyransac3d as pyrsc

points = load_points(.) # Load your point cloud as a numpy array (N, 3)

plane1 = pyrsc.Plane()
best_eq, best_inliers = plane1.fit(points, 0.01)

```

--------------------------------

### fit Method

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/cylinder

Finds the parameters (axis and radius) defining a cylinder within a 3D point cloud using the RANSAC algorithm.

```APIDOC
## fit(pts, thresh=0.2, maxIteration=10000)

### Description
Finds the parameters (axis and radius) defining a cylinder.

### Method
```python
fit(pts, thresh=0.2, maxIteration=10000)
```

### Parameters
#### Arguments
- **pts** (numpy.array) - 3D point cloud as a numpy array (N,3).
- **thresh** (float) - Threshold distance from the cylinder hull which is considered inlier. Defaults to 0.2.
- **maxIteration** (int) - Number of maximum iteration which RANSAC will loop over. Defaults to 10000.

### Returns
- **center** (numpy.array) - Center of the cylinder np.array(1,3) which the cylinder axis is passing through.
- **axis** (numpy.array) - Vector describing cylinder's axis np.array(1,3).
- **radius** (float) - Radius of cylinder.
- **inliers** (list) - Inlier's index from the original point cloud.
```

--------------------------------

### Fit a Sphere using RANSAC

Source: https://leomariga.github.io/pyRANSAC-3D

Use the Sphere class to fit a sphere to a point cloud. Load your point cloud data into a numpy array of shape (N, 3). The fit method returns the sphere's center, radius, and the inlier points.

```python
import pyransac3d as pyrsc

points = load_points(.) # Load your point cloud as a numpy array (N, 3)

sph = pyrsc.Sphere()
center, radius, inliers = sph.fit(points, thresh=0.4)

```

--------------------------------

### Point.fit

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/point

Finds the best point in a 3D point cloud using the RANSAC algorithm. It identifies a point as the best candidate if it has the most neighbors within a given radius.

```APIDOC
## Point.fit

### Description
Finds the best point in a 3D point cloud using the RANSAC algorithm. It identifies a point as the best candidate if it has the most neighbors within a given radius.

### Method
fit

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **pts** (np.array (N,3)) - Required - 3D point cloud.
* **thresh** (float) - Optional - Threshold radius from the point which is considered inlier. Defaults to 0.2.
* **maxIteration** (int) - Optional - Number of maximum iteration which RANSAC will loop over. Defaults to 10000.

### Response
#### Success Response
* **center** (np.array (1, 3)) - Point selected as best candidate.
* **inliers** (np.array (1, M)) - Inlier's index from the original point cloud.
```

--------------------------------

### Fit Plane Equation

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/plane

Finds the best plane equation using RANSAC. Requires a 3D point cloud and accepts optional parameters for distance threshold, minimum inliers, and maximum iterations.

```python
fit(pts, thresh=0.05, minPoints=100, maxIteration=1000)
```

--------------------------------

### Fit Cylinder Parameters

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/cylinder

Finds the axis, center, and radius of a cylinder within a 3D point cloud using RANSAC. Requires a numpy array of points and accepts optional RANSAC parameters for threshold and maximum iterations.

```python
 | fit(pts, thresh=0.2, maxIteration=10000)
```

--------------------------------

### Line.fit

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/line

Finds the best equation for a 3D line using the RANSAC method. The line is defined by y = Ax + B, where A and B are vectors.

```APIDOC
## Line.fit

### Description
Finds the best equation for the 3D line. The line in a 3d enviroment is defined as y = Ax+B, but A and B are vectors intead of scalars.

### Method Signature
`fit(pts, thresh=0.2, maxIteration=1000)`

### Parameters
#### Arguments
- **pts** (np.array (N,3)) - Required - 3D point cloud.
- **thresh** (float) - Optional - Threshold distance from the line which is considered inlier. Defaults to 0.2.
- **maxIteration** (int) - Optional - Number of maximum iteration which RANSAC will loop over. Defaults to 1000.

### Returns
- **A** (np.array (1, 3)) - 3D slope of the line (angle).
- **B** (np.array (1, 3)) - Axis interception.
- **inliers** (np.array (1, M)) - Inlier's index from the original point cloud.
```

--------------------------------

### Circle.fit

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/circle

Finds the parameters (axis, radius, and center) to define a circle within a 3D point cloud using the RANSAC algorithm. It takes the point cloud, a distance threshold, and the maximum number of iterations as input.

```APIDOC
## Circle.fit

### Description
Finds the parameters (axis and radius and center) to define a circle.

### Method
fit

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **pts** (numpy array (N,3)) - Required - 3D point cloud.
* **thresh** (float) - Optional - Threshold distance from the cylinder hull which is considered inlier. Defaults to 0.2.
* **maxIteration** (int) - Optional - Number of maximum iteration which RANSAC will loop over. Defaults to 1000.

### Request Example
```python
# Example usage (assuming pts is a numpy array of shape (N, 3))
circle.fit(pts, thresh=0.2, maxIteration=1000)
```

### Response
#### Success Response
* **center** (np.array(1,3)) - Center of the circle np.array(1,3) which the circle center is passing through.
* **axis** (np.array(1,3)) - Vector describing circle's plane normal as np.array(1,3).
* **radius** (float) - Radius of the circle.
* **inliers** (list of int) - Inlier's index from the original point cloud.

#### Response Example
```json
{
  "center": [x, y, z],
  "axis": [nx, ny, nz],
  "radius": r,
  "inliers": [index1, index2, ...]
}
```
```

--------------------------------

### Cylinder Class Constructor

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/cylinder

Initializes the Cylinder class. Note: The current cylinder RANSAC implementation may not yield good results on real data; improvements are in progress.

```python
class Cylinder():
 |  Cylinder()
```

--------------------------------

### Sphere.fit

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/sphere

Finds the parameters (center and radius) to define a Sphere using RANSAC. It takes a 3D point cloud and fitting parameters as input and returns the sphere's center, radius, and inlier indices.

```APIDOC
## Sphere.fit

### Description
Finds the parameters (center and radius) to define a Sphere. This method implements the RANSAC algorithm to identify inliers and estimate the sphere's geometric properties from a given point cloud.

### Method
`fit(pts, thresh=0.2, maxIteration=1000)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
#### Arguments
* `pts` (numpy.array) - Required - 3D point cloud as a numpy array (N,3).
* `thresh` (float) - Optional - Threshold distance from the Sphere hull which is considered inlier. Defaults to 0.2.
* `maxIteration` (int) - Optional - Number of maximum iteration which RANSAC will loop over. Defaults to 1000.

### Returns
* `center` (numpy.array) - Center of the sphere np.array(1,3).
* `radius` (float) - Radius of the sphere.
* `inliers` (list) - Inlier's index from the original point cloud.
```

--------------------------------

### Fit Method for Circle Detection

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/circle

Finds circle parameters using RANSAC. Requires a 3D point cloud and optional RANSAC parameters. Returns circle properties and inlier indices.

```python
 | fit(pts, thresh=0.2, maxIteration=1000)

```

--------------------------------

### Cuboid.fit

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/cuboid

Finds the best plane equations for three orthogonal planes that define a cuboid within a 3D point cloud using RANSAC. It identifies inliers based on a specified threshold and maximum iterations.

```APIDOC
## Cuboid.fit

### Description
Finds the best equation for 3 planes which define a complete cuboid.

### Method Signature
`fit(pts, thresh=0.05, maxIteration=5000)`

### Parameters
#### Arguments
*   **pts** (np.array (N,3)) - Required - 3D point cloud.
*   **thresh** (float) - Optional - Threshold distance from the plane which is considered inlier. Defaults to 0.05.
*   **maxIteration** (int) - Optional - Number of maximum iterations for the RANSAC algorithm. Defaults to 5000.

### Returns
*   **best_eq** (np.array (3, 4)) - Array of 3 best planes's equation.
*   **best_inliers** (np.array (1, M)) - Inlier's index from the original point cloud.
```

--------------------------------

### Cylinder Class

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/cylinder

Initializes the Cylinder object. Note: The cylinder RANSAC is not performing well on real data in the current version and is being improved.

```APIDOC
## Cylinder()

### Description
Initializes the Cylinder object.

### Method
```python
Cylinder()
```
```

--------------------------------

### Create Rotation Matrix from Vectors

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/auxiliary

Generates a 3D rotation matrix to transform vector u to vector v. Requires numpy arrays for input vectors.

```python
get_rotationMatrix_from_vectors(u, v)


```

--------------------------------

### Fit Method for Point RANSAC

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/point

The fit method finds the best point in a 3D point cloud using RANSAC. It requires a point cloud and a threshold radius to define neighbors. The maximum number of iterations can also be set.

```python
 | fit(pts, thresh=0.2, maxIteration=10000)

```

--------------------------------

### Rotate Points using Rodrigues' Formula

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/auxiliary

Rotates a set of 3D points from an origin normal vector to a destination normal vector using Rodrigues' formula. Requires numpy arrays for points and normal vectors.

```python
rodrigues_rot(P, n0, n1)


```

--------------------------------

### Fit Method for 3D Line RANSAC

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/line

Finds the best equation for a 3D line using RANSAC. The line is defined by y = Ax+B, where A and B are vectors. Use this method to determine the line parameters and inliers from a 3D point cloud.

```python
 | fit(pts, thresh=0.2, maxIteration=1000)
```

--------------------------------

### Plane Class

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/plane

The Plane class is used to find the equation of an infinite plane using the RANSAC algorithm. The `fit` method can be called to detect the best plane equation from a given point cloud.

```APIDOC
## Plane()

### Description
Initializes the Plane object.

### Method
```python
Plane()
```
```

```APIDOC
## fit(pts, thresh=0.05, minPoints=100, maxIteration=1000)

### Description
Finds the best equation for a plane using the RANSAC algorithm.

### Method
```python
fit(pts, thresh=0.05, minPoints=100, maxIteration=1000)
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **pts** (np.array (N,3)) - Required - 3D point cloud data.
* **thresh** (float) - Optional - Threshold distance from the plane to consider points as inliers. Defaults to 0.05.
* **minPoints** (int) - Optional - Minimum number of points required to form a plane. Defaults to 100.
* **maxIteration** (int) - Optional - Maximum number of iterations for the RANSAC algorithm. Defaults to 1000.

### Returns
* **self.equation** (np.array (1, 4)) - The parameters of the plane in the form Ax+By+Cz+D.
* **self.inliers** (list) - A list of points from the dataset considered as inliers.
```

--------------------------------

### Sphere Class Definition

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/sphere

Defines the Sphere class for RANSAC-based sphere fitting. It is based on the 'PGP2X: Principal Geometric Primitives Parameters Extraction' article.

```python
class Sphere():
 |  Sphere()

```

--------------------------------

### Line Class Definition

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/line

Defines the Line class for 3D RANSAC.

```python
class Line():
 |  Line()
```

--------------------------------

### Cuboid Class Definition

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/cuboid

Defines the Cuboid class. This is a basic class structure.

```python
class Cuboid():
 |  Cuboid()

```

--------------------------------

### Circle Class Definition

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/circle

Defines the Circle class used for RANSAC-based circle fitting. It is initialized without arguments.

```python
class Circle():
 |  Circle()

```

--------------------------------

### get_rotationMatrix_from_vectors

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/auxiliary

Generates a rotation matrix to transform one 3D vector to another.

```APIDOC
## get_rotationMatrix_from_vectors

### Description
Create a rotation matrix that rotates the space from a 3D vector `u` to a 3D vector `v`.

### Arguments
#### Path Parameters
- **u** (np.array (1,3)) - Required - Orign vector.
- **v** (np.array (1,3)) - Required - Destiny vector.

### Returns
#### Success Response (200)
- **Rotation matrix** (np.array (3, 3)) - The resulting rotation matrix.

### Request Example
```python
get_rotationMatrix_from_vectors(u, v)
```

### Response Example
```json
{
  "rotation_matrix": [[...], [...], [...]]
}
```
```

--------------------------------

### Point Class Definition

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/point

Defines the Point class for RANSAC-based point finding in 3D space. It identifies the point with the most neighbors within a specified radius.

```python
class Point():
 |  Point()

```

--------------------------------

### rodrigues_rot

Source: https://leomariga.github.io/pyRANSAC-3D/api-documentation/auxiliary

Rotates a set of points between two normal vectors using Rodrigues' formula.

```APIDOC
## rodrigues_rot

### Description
Rotate a set of point between two normal vectors using Rodrigues' formula.

### Arguments
#### Path Parameters
- **P** (np.array (N,3)) - Required - Set of points.
- **n0** (np.array (1,3)) - Required - Orign vector.
- **n1** (np.array (1,3)) - Required - Destiny vector.

### Returns
#### Success Response (200)
- **Set of points P, but rotated** (np.array (N, 3)) - The rotated set of points.

### Request Example
```python
rodrigues_rot(P, n0, n1)
```

### Response Example
```json
{
  "rotated_points": [[...], [...], ...]
}
```
```
Tokens:
Raw