Plane

class ladybug_geometry.geometry3d.plane.Plane(n=Vector3D(0.0, 0.0, 1.0), o=Point3D(0.0, 0.0, 0.0), x=None)[source]

Bases: `object`

Plane object.

Parameters
• n – A Vector3D representing the normal of the plane.

• o – A Point3D representing the origin point of the plane.

• x – An optional Vector3D for the X-Axis of the Plane. Note that this vector must be orthogonal to the input normal vector. If None, the default will find an X-Axis in the world XY plane.

Properties:
• n

• o

• k

• x

• y

• tilt

• altitude

• azimuth

• min

• max

ToString()[source]

Overwrite .NET ToString.

closest_point(point)[source]

Get the closest Point3D on this plane to another Point3D.

Parameters

point – A Point3D object to which the closest point on this plane will be computed.

Returns

Point3D for the closest point on this plane to the input point.

closest_points_between_line(line_ray)[source]

Get the two closest Point3D between this plane and a Line3D or Ray3D.

Parameters

line_ray – A Line3D or Ray3D object to which the closest points will be computed.

Returns

Two Point3D objects representing

1. The closest point on the input line_ray to this plane.

2. The closest point on this plane to the input line_ray.

Will be None if the line_ray intersects this plant

distance_to_line(line_ray)[source]

Get the minimum distance between this plane and the input Line3D or Ray3D.

Parameters

line_ray – A Line3D or Ray3D object to which the minimum distance will be computed.

Returns

The minimum distance to the input line_ray.

distance_to_point(point)[source]

Get the minimum distance between this plane and the input point.

Parameters

point – A Point3D object to which the minimum distance will be computed.

Returns

The distance to the input point.

duplicate()[source]

Get a copy of this object.

flip()[source]

Get a flipped version of this plane (facing the opposite direction).

classmethod from_dict(data)[source]

Create a Plane from a dictionary.

```{
"type": "Plane"
"n": (0, 0, 1),
"o": (0, 10, 0),
"x": (1, 0, 0)
}
```
classmethod from_normal_k(n, k)[source]

Initialize a Plane from a normal vector and a scalar constant.

Parameters
• o – A Point3D representing the origin point of the plane.

• k – Scalar constant relating origin point to normal vector

classmethod from_three_points(o, p2, p3)[source]

Initialize a Plane from three Point3D objects that are not co-linear.

Parameters
• o – A Point3D representing the origin point of the plane.

• p2 – A Point3D representing a point the plane.

• p3 – A Point3D representing a point the plane.

intersect_arc(arc)[source]

Get the intersection between this Plane and an Arc3D.

Parameters

plane – A Plane object for which intersection will be computed.

Returns

A list of 2 Point3D objects if a full intersection exists. A list with a single Point3D object if the line is tangent or intersects only once. None if no intersection exists.

intersect_line_ray(line_ray)[source]

Get the intersection between this plane and the input Line3D or Ray3D.

Parameters

line_ray – A Line3D or Ray3D object for which intersection will be computed.

Returns

Point3D for the intersection. Will be None if no intersection exists.

intersect_plane(plane)[source]

Get the intersection between this Plane and another Plane.

Parameters

plane – A Plane object for which intersection will be computed.

Returns

Ray3D for the intersection. Will be None if planes are parallel.

is_coplanar(plane)[source]

Test if another Plane object is perfectly coplanar with this Plane.

Parameters

plane – A Plane object for which co-planarity will be tested.

Returns

True if plane is coplanar. False if it is not coplanar.

is_coplanar_tolerance(plane, tolerance, angle_tolerance)[source]

Test if another Plane object is coplanar within a certain tolerance.

Parameters
• plane – A Plane object for which co-planarity will be tested.

• tolerance – The distance between the two planes at which point they can be considered coplanar.

• angle_tolerance – The angle in radians that the plane normals can differ from one another in order for the planes to be considered coplanar.

Returns

True if plane is coplanar. False if it is not coplanar.

is_point_above(point)[source]

Test if a given point is above or below this plane.

Above is defined as being on the side of the plane that the plane normal is pointing towards.

Parameters

point – A Point3D object to test.

Returns

True is point is above; False if below.

move(moving_vec)[source]

Get a plane that has been moved along a vector.

Parameters

moving_vec – A Vector3D with the direction and distance to move the plane.

project_point(point, projection_direction=None)[source]

Project a point onto this Plane given a certain projection direction.

Parameters
• point – A Point3D to be projected onto the plane

• projection_direction – A Line3D or Ray3D object to set the direction of projection. If None, this Plane’s normal will be used. (Default: None).

Returns

Point3D for the projected point. Will be None if the projection_direction is parallel to the plane.

reflect(normal, origin)[source]

Get a plane reflected across a plane with the input normal vector and origin.

Parameters
• normal – A Vector3D representing the normal vector for the plane across which the plane will be reflected. THIS VECTOR MUST BE NORMALIZED.

• origin – A Point3D representing the origin from which to reflect.

rotate(axis, angle, origin)[source]

Rotate a plane by a certain angle around an axis and origin.

Right hand rule applies: If axis has a positive orientation, rotation will be clockwise. If axis has a negative orientation, rotation will be counterclockwise.

Parameters
• axis – A Vector3D axis representing the axis of rotation.

• angle – An angle for rotation in radians.

• origin – A Point3D for the origin around which the object will be rotated.

rotate_xy(angle, origin)[source]

Get a plane rotated counterclockwise in the world XY plane by a certain angle.

Parameters
• angle – An angle in radians.

• origin – A Point3D for the origin around which the object will be rotated.

scale(factor, origin=None)[source]

Scale a plane by a factor from an origin point.

Parameters
• factor – A number representing how much the plane should be scaled.

• origin – A Point3D representing the origin from which to scale. If None, it will be scaled from the World origin (0, 0, 0).

to_dict()[source]

Get Plane as a dictionary.

xy_to_xyz(point)[source]

Get a Point3D from a Point2D in the coordinate system of this plane.

xyz_to_xy(point)[source]

Get a Point2D in the coordinate system of this plane from a Point3D.

Note that the input Point3D should lie within this plane object in order for the result to be valid.

property altitude

Get the altitude of the plane. Between Pi/2 (up) and -Pi/2 (down).

property azimuth

Get the azimuth of the plane.

This is always between 0, indicating the positive Y-axis, and moving clockwise up to 2 * Pi, which indicates a return to the positive Y-axis.

This will be zero if the plane is perfectly horizontal.

property k

Scalar constant relating origin point to normal vector.

property max

Returns the Plane origin.

property min

Returns the Plane origin.

property n

Normal vector. This vector will always be normalized (magnitude = 1).

property o

Origin point.

property tilt

Get the tilt of the plane. Between 0 (up) and Pi (down).

property x

Plane X-Axis. This vector will always be normalized (magnitude = 1).

property y

Plane Y-Axis. This vector will always be normalized (magnitude = 1).