fake-bpy-module 20240327__py3-none-any.whl → 20240330__py3-none-any.whl

mathutils/bvhtree/__init__.pyi

@@ -9,13 +9,12 @@ class BVHTree:
     """ """
 
     @classmethod
-    def FromBMesh(cls, bmesh: bmesh.types.BMesh, epsilon: float = 0.0):
+    def FromBMesh(cls, bmesh: bmesh.types.BMesh, epsilon=0.0):
         """BVH tree based on `BMesh` data.
 
         :param bmesh: BMesh data.
         :type bmesh: bmesh.types.BMesh
         :param epsilon: Increase the threshold for detecting overlap and raycast hits.
-        :type epsilon: float
         """
         ...
 
@@ -27,7 +26,7 @@ class BVHTree:
         deform: bool = True,
         render=False,
         cage: bool = False,
-        epsilon: float = 0.0,
+        epsilon=0.0,
     ):
         """BVH tree based on `Object` data.
 
@@ -41,14 +40,11 @@ class BVHTree:
         :param cage: Use modifiers cage.
         :type cage: bool
         :param epsilon: Increase the threshold for detecting overlap and raycast hits.
-        :type epsilon: float
         """
         ...
 
     @classmethod
-    def FromPolygons(
-        cls, vertices, polygons, all_triangles: bool = False, epsilon: float = 0.0
-    ):
+    def FromPolygons(cls, vertices, polygons, all_triangles: bool = False, epsilon=0.0):
         """BVH tree constructed geometry passed in as arguments.
 
         :param vertices: float triplets each representing (x, y, z)
@@ -56,16 +52,14 @@ class BVHTree:
         :param all_triangles: Use when all polygons are triangles for more efficient conversion.
         :type all_triangles: bool
         :param epsilon: Increase the threshold for detecting overlap and raycast hits.
-        :type epsilon: float
         """
         ...
 
-    def find_nearest(self, origin, distance: float = 1.84467e19) -> float:
+    def find_nearest(self, origin, distance=1.84467e19):
         """Find the nearest element (typically face index) to a point.
 
                 :param origin:
                 :param distance: Maximum distance threshold.
-                :type distance: float
                 :return: Returns a tuple
         (`Vector` location, `Vector` normal, int index, float distance),
         Values will all be None if no hit is found.
@@ -73,12 +67,11 @@ class BVHTree:
         """
         ...
 
-    def find_nearest_range(self, origin, distance: float = 1.84467e19) -> float:
+    def find_nearest_range(self, origin, distance=1.84467e19):
         """Find the nearest elements (typically face index) to a point in the distance range.
 
                 :param origin:
                 :param distance: Maximum distance threshold.
-                :type distance: float
                 :return: Returns a list of tuples
         (`Vector` location, `Vector` normal, int index, float distance),
                 :rtype: list
@@ -99,8 +92,8 @@ class BVHTree:
         self,
         origin: typing.Union[typing.Sequence[float], mathutils.Vector],
         direction: typing.Union[typing.Sequence[float], mathutils.Vector],
-        distance: float = None,
-    ) -> float:
+        distance=None,
+    ):
         """Cast a ray onto the mesh.
 
                 :param origin: Start location of the ray in object space.
@@ -108,7 +101,6 @@ class BVHTree:
                 :param direction: Direction of the ray in object space.
                 :type direction: typing.Union[typing.Sequence[float], mathutils.Vector]
                 :param distance: Maximum distance threshold.
-                :type distance: float
                 :return: Returns a tuple
         (`Vector` location, `Vector` normal, int index, float distance),
         Values will all be None if no hit is found.

mathutils/geometry/__init__.pyi

@@ -7,7 +7,7 @@ def area_tri(
     v1: typing.Union[typing.Sequence[float], mathutils.Vector],
     v2: typing.Union[typing.Sequence[float], mathutils.Vector],
     v3: typing.Union[typing.Sequence[float], mathutils.Vector],
-) -> float:
+):
     """Returns the area size of the 2D or 3D triangle defined.
 
     :param v1: Point1
@@ -16,7 +16,6 @@ def area_tri(
     :type v2: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param v3: Point3
     :type v3: typing.Union[typing.Sequence[float], mathutils.Vector]
-    :rtype: float
     """
 
     ...
@@ -51,13 +50,12 @@ def barycentric_transform(
 
     ...
 
-def box_fit_2d(points: list) -> float:
+def box_fit_2d(points: list):
     """Returns an angle that best fits the points to an axis aligned rectangle
 
     :param points: list of 2d points.
     :type points: list
     :return: angle
-    :rtype: float
     """
 
     ...
@@ -141,7 +139,7 @@ def distance_point_to_plane(
     pt: typing.Union[typing.Sequence[float], mathutils.Vector],
     plane_co: typing.Union[typing.Sequence[float], mathutils.Vector],
     plane_no: typing.Union[typing.Sequence[float], mathutils.Vector],
-) -> float:
+):
     """Returns the signed distance between a point and a plane    (negative when below the normal).
 
     :param pt: Point
@@ -150,7 +148,6 @@ def distance_point_to_plane(
     :type plane_co: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param plane_no: The direction the plane is facing
     :type plane_no: typing.Union[typing.Sequence[float], mathutils.Vector]
-    :rtype: float
     """
 
     ...
@@ -160,7 +157,7 @@ def interpolate_bezier(
     handle1: typing.Union[typing.Sequence[float], mathutils.Vector],
     handle2: typing.Union[typing.Sequence[float], mathutils.Vector],
     knot2: typing.Union[typing.Sequence[float], mathutils.Vector],
-    resolution: int,
+    resolution,
 ):
     """Interpolate a bezier spline segment.
 
@@ -173,7 +170,6 @@ def interpolate_bezier(
     :param knot2: Second bezier spline point.
     :type knot2: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param resolution: Number of points to return.
-    :type resolution: int
     :return: The interpolated points
     """
 
@@ -335,7 +331,7 @@ def intersect_point_quad_2d(
     quad_p2: typing.Union[typing.Sequence[float], mathutils.Vector],
     quad_p3: typing.Union[typing.Sequence[float], mathutils.Vector],
     quad_p4: typing.Union[typing.Sequence[float], mathutils.Vector],
-) -> int:
+):
     """Takes 5 vectors (using only the x and y coordinates): one is the point and the next 4 define the quad,
     only the x and y are used from the vectors. Returns 1 if the point is within the quad, otherwise 0.
     Works only with convex quads without singular edges.
@@ -350,7 +346,6 @@ def intersect_point_quad_2d(
         :type quad_p3: typing.Union[typing.Sequence[float], mathutils.Vector]
         :param quad_p4: Fourth point of the quad
         :type quad_p4: typing.Union[typing.Sequence[float], mathutils.Vector]
-        :rtype: int
     """
 
     ...
@@ -381,7 +376,7 @@ def intersect_point_tri_2d(
     tri_p1: typing.Union[typing.Sequence[float], mathutils.Vector],
     tri_p2: typing.Union[typing.Sequence[float], mathutils.Vector],
     tri_p3: typing.Union[typing.Sequence[float], mathutils.Vector],
-) -> int:
+):
     """Takes 4 vectors (using only the x and y coordinates): one is the point and the next 3 define the triangle. Returns 1 if the point is within the triangle, otherwise 0.
 
     :param pt: Point
@@ -392,7 +387,6 @@ def intersect_point_tri_2d(
     :type tri_p2: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param tri_p3: Third point of the triangle
     :type tri_p3: typing.Union[typing.Sequence[float], mathutils.Vector]
-    :rtype: int
     """
 
     ...
@@ -426,20 +420,18 @@ def intersect_ray_tri(
 
 def intersect_sphere_sphere_2d(
     p_a: typing.Union[typing.Sequence[float], mathutils.Vector],
-    radius_a: float,
+    radius_a,
     p_b: typing.Union[typing.Sequence[float], mathutils.Vector],
-    radius_b: float,
+    radius_b,
 ) -> typing.Tuple[mathutils.Vector]:
     """Returns 2 points on between intersecting circles.
 
     :param p_a: Center of the first circle
     :type p_a: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param radius_a: Radius of the first circle
-    :type radius_a: float
     :param p_b: Center of the second circle
     :type p_b: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param radius_b: Radius of the second circle
-    :type radius_b: float
     :rtype: typing.Tuple[mathutils.Vector]
     """
 
@@ -486,7 +478,7 @@ def volume_tetrahedron(
     v2: typing.Union[typing.Sequence[float], mathutils.Vector],
     v3: typing.Union[typing.Sequence[float], mathutils.Vector],
     v4: typing.Union[typing.Sequence[float], mathutils.Vector],
-) -> float:
+):
     """Return the volume formed by a tetrahedron (points can be in any order).
 
     :param v1: Point1
@@ -497,7 +489,6 @@ def volume_tetrahedron(
     :type v3: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param v4: Point4
     :type v4: typing.Union[typing.Sequence[float], mathutils.Vector]
-    :rtype: float
     """
 
     ...

mathutils/kdtree/__init__.pyi

@@ -26,43 +26,36 @@ class KDTree:
         """
         ...
 
-    def find_n(
-        self, co: typing.Union[typing.Sequence[float], mathutils.Vector], n: int
-    ) -> int:
+    def find_n(self, co: typing.Union[typing.Sequence[float], mathutils.Vector], n):
         """Find nearest n points to co.
 
         :param co: 3d coordinates.
         :type co: typing.Union[typing.Sequence[float], mathutils.Vector]
         :param n: Number of points to find.
-        :type n: int
         :return: Returns a list of tuples (`Vector`, index, distance).
         :rtype: list
         """
         ...
 
     def find_range(
-        self, co: typing.Union[typing.Sequence[float], mathutils.Vector], radius: float
-    ) -> float:
+        self, co: typing.Union[typing.Sequence[float], mathutils.Vector], radius
+    ):
         """Find all points within radius of co.
 
         :param co: 3d coordinates.
         :type co: typing.Union[typing.Sequence[float], mathutils.Vector]
         :param radius: Distance to search for points.
-        :type radius: float
         :return: Returns a list of tuples (`Vector`, index, distance).
         :rtype: list
         """
         ...
 
-    def insert(
-        self, co: typing.Union[typing.Sequence[float], mathutils.Vector], index: int
-    ):
+    def insert(self, co: typing.Union[typing.Sequence[float], mathutils.Vector], index):
         """Insert a point into the KDTree.
 
         :param co: Point 3d position.
         :type co: typing.Union[typing.Sequence[float], mathutils.Vector]
         :param index: The index of the point.
-        :type index: int
         """
         ...
 

mathutils/noise/__init__.pyi

@@ -3,13 +3,12 @@ import mathutils
 
 GenericType = typing.TypeVar("GenericType")
 
-def cell(position: typing.Union[typing.Sequence[float], mathutils.Vector]) -> float:
+def cell(position: typing.Union[typing.Sequence[float], mathutils.Vector]):
     """Returns cell noise value at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :return: The cell noise value.
-    :rtype: float
     """
 
     ...
@@ -29,109 +28,90 @@ def cell_vector(
 
 def fractal(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    H: float,
-    lacunarity: float,
-    octaves: int,
+    H,
+    lacunarity,
+    octaves,
     noise_basis: str = "PERLIN_ORIGINAL",
-) -> float:
+):
     """Returns the fractal Brownian motion (fBm) noise value from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param H: The fractal increment factor.
-    :type H: float
     :param lacunarity: The gap between successive frequencies.
-    :type lacunarity: float
     :param octaves: The number of different noise frequencies used.
-    :type octaves: int
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :return: The fractal Brownian motion noise value.
-    :rtype: float
     """
 
     ...
 
 def hetero_terrain(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    H: float,
-    lacunarity: float,
-    octaves: int,
-    offset: float,
+    H,
+    lacunarity,
+    octaves,
+    offset,
     noise_basis: str = "PERLIN_ORIGINAL",
-) -> float:
+):
     """Returns the heterogeneous terrain value from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param H: The fractal dimension of the roughest areas.
-    :type H: float
     :param lacunarity: The gap between successive frequencies.
-    :type lacunarity: float
     :param octaves: The number of different noise frequencies used.
-    :type octaves: int
     :param offset: The height of the terrain above 'sea level'.
-    :type offset: float
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :return: The heterogeneous terrain value.
-    :rtype: float
     """
 
     ...
 
 def hybrid_multi_fractal(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    H: float,
-    lacunarity: float,
-    octaves: int,
-    offset: float,
-    gain: float,
+    H,
+    lacunarity,
+    octaves,
+    offset,
+    gain,
     noise_basis: str = "PERLIN_ORIGINAL",
-) -> float:
+):
     """Returns hybrid multifractal value from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param H: The fractal dimension of the roughest areas.
-    :type H: float
     :param lacunarity: The gap between successive frequencies.
-    :type lacunarity: float
     :param octaves: The number of different noise frequencies used.
-    :type octaves: int
     :param offset: The height of the terrain above 'sea level'.
-    :type offset: float
     :param gain: Scaling applied to the values.
-    :type gain: float
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :return: The hybrid multifractal value.
-    :rtype: float
     """
 
     ...
 
 def multi_fractal(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    H: float,
-    lacunarity: float,
-    octaves: int,
+    H,
+    lacunarity,
+    octaves,
     noise_basis: str = "PERLIN_ORIGINAL",
-) -> float:
+):
     """Returns multifractal noise value from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param H: The fractal increment factor.
-    :type H: float
     :param lacunarity: The gap between successive frequencies.
-    :type lacunarity: float
     :param octaves: The number of different noise frequencies used.
-    :type octaves: int
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :return: The multifractal noise value.
-    :rtype: float
     """
 
     ...
@@ -139,7 +119,7 @@ def multi_fractal(
 def noise(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
     noise_basis: str = "PERLIN_ORIGINAL",
-) -> float:
+):
     """Returns noise value from the noise basis at the position specified.
 
     :param position: The position to evaluate the selected noise function.
@@ -147,7 +127,6 @@ def noise(
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :return: The noise value.
-    :rtype: float
     """
 
     ...
@@ -168,31 +147,28 @@ def noise_vector(
 
     ...
 
-def random() -> float:
+def random():
     """Returns a random number in the range [0, 1).
 
     :return: The random number.
-    :rtype: float
     """
 
     ...
 
-def random_unit_vector(size: int = 3) -> mathutils.Vector:
+def random_unit_vector(size=3) -> mathutils.Vector:
     """Returns a unit vector with random entries.
 
     :param size: The size of the vector to be produced, in the range [2, 4].
-    :type size: int
     :return: The random unit vector.
     :rtype: mathutils.Vector
     """
 
     ...
 
-def random_vector(size: int = 3) -> mathutils.Vector:
+def random_vector(size=3) -> mathutils.Vector:
     """Returns a vector with random entries in the range (-1, 1).
 
     :param size: The size of the vector to be produced.
-    :type size: int
     :return: The random vector.
     :rtype: mathutils.Vector
     """
@@ -201,95 +177,81 @@ def random_vector(size: int = 3) -> mathutils.Vector:
 
 def ridged_multi_fractal(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    H: float,
-    lacunarity: float,
-    octaves: int,
-    offset: float,
-    gain: float,
+    H,
+    lacunarity,
+    octaves,
+    offset,
+    gain,
     noise_basis: str = "PERLIN_ORIGINAL",
-) -> float:
+):
     """Returns ridged multifractal value from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param H: The fractal dimension of the roughest areas.
-    :type H: float
     :param lacunarity: The gap between successive frequencies.
-    :type lacunarity: float
     :param octaves: The number of different noise frequencies used.
-    :type octaves: int
     :param offset: The height of the terrain above 'sea level'.
-    :type offset: float
     :param gain: Scaling applied to the values.
-    :type gain: float
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :return: The ridged multifractal value.
-    :rtype: float
     """
 
     ...
 
-def seed_set(seed: int):
+def seed_set(seed):
     """Sets the random seed used for random_unit_vector, and random.
 
         :param seed: Seed used for the random generator.
     When seed is zero, the current time will be used instead.
-        :type seed: int
     """
 
     ...
 
 def turbulence(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    octaves: int,
+    octaves,
     hard: bool,
     noise_basis: str = "PERLIN_ORIGINAL",
-    amplitude_scale: float = 0.5,
-    frequency_scale: float = 2.0,
-) -> float:
+    amplitude_scale=0.5,
+    frequency_scale=2.0,
+):
     """Returns the turbulence value from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param octaves: The number of different noise frequencies used.
-    :type octaves: int
     :param hard: Specifies whether returned turbulence is hard (sharp transitions) or soft (smooth transitions).
     :type hard: bool
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :param amplitude_scale: The amplitude scaling factor.
-    :type amplitude_scale: float
     :param frequency_scale: The frequency scaling factor
-    :type frequency_scale: float
     :return: The turbulence value.
-    :rtype: float
     """
 
     ...
 
 def turbulence_vector(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    octaves: int,
+    octaves,
     hard: bool,
     noise_basis: str = "PERLIN_ORIGINAL",
-    amplitude_scale: float = 0.5,
-    frequency_scale: float = 2.0,
+    amplitude_scale=0.5,
+    frequency_scale=2.0,
 ) -> mathutils.Vector:
     """Returns the turbulence vector from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param octaves: The number of different noise frequencies used.
-    :type octaves: int
     :param hard: Specifies whether returned turbulence is hard (sharp transitions) or soft (smooth transitions).
     :type hard: bool
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :param amplitude_scale: The amplitude scaling factor.
-    :type amplitude_scale: float
     :param frequency_scale: The frequency scaling factor
-    :type frequency_scale: float
     :return: The turbulence vector.
     :rtype: mathutils.Vector
     """
@@ -298,22 +260,20 @@ def turbulence_vector(
 
 def variable_lacunarity(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    distortion: float,
+    distortion,
     noise_type1: str = "PERLIN_ORIGINAL",
     noise_type2: str = "PERLIN_ORIGINAL",
-) -> float:
+):
     """Returns variable lacunarity noise value, a distorted variety of noise, from noise type 1 distorted by noise type 2 at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param distortion: The amount of distortion.
-    :type distortion: float
     :param noise_type1: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_type1: str
     :param noise_type2: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_type2: str
     :return: The variable lacunarity noise value.
-    :rtype: float
     """
 
     ...
@@ -321,7 +281,7 @@ def variable_lacunarity(
 def voronoi(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
     distance_metric: str = "DISTANCE",
-    exponent: float = 2.5,
+    exponent=2.5,
 ):
     """Returns a list of distances to the four closest features and their locations.
 
@@ -330,7 +290,6 @@ def voronoi(
     :param distance_metric: Enumerator in ['DISTANCE', 'DISTANCE_SQUARED', 'MANHATTAN', 'CHEBYCHEV', 'MINKOVSKY', 'MINKOVSKY_HALF', 'MINKOVSKY_FOUR'].
     :type distance_metric: str
     :param exponent: The exponent for Minkowski distance metric.
-    :type exponent: float
     :return: A list of distances to the four closest features and their locations.
     """