mapteksdk.data.facets module

Facet data types.

This contains objects which use facet primitives. Currently there is only one such data type (Surface).

class Surface(object_id=None, lock_type=LockType.READWRITE)

Bases: mapteksdk.data.primitives.point_properties.PointProperties, mapteksdk.data.primitives.edge_properties.EdgeProperties, mapteksdk.data.primitives.facet_properties.FacetProperties, mapteksdk.data.base.Topology

Surfaces are represented by triangular facets defined by three points. This means a square or rectangle is represented by two facets, a cube is represented as twelve facets (six squares, each made of two facets). More complicated surfaces may require hundreds, thousands or more facets to be represented.

Defining a surface requires the points and the facets to be defined - the edges are automatically populated when the object is saved. A facet is a three element long list where each element is the index of a point, for example the facet [0, 1, 4] would indicate the facet is the triangle between points 0, 1 and 4.

Notes

The edges of a facet network are derived from the points and facets and cannot be directly set.

Examples

Creating a pyramid with a square base.

>>> from mapteksdk.project import Project
>>> from mapteksdk.data import Surface
>>> project = Project()
>>> with project.new("surfaces/pyramid", Surface) as new_pyramid:
>>>     new_pyramid.points = [[0, 0, 0], [2, 0, 0], [2, 2, 0],
>>>                           [0, 2, 0], [1, 1, 1]]
>>>     new_pyramid.facets = [[0, 1, 2], [0, 2, 3], [0, 1, 4], [1, 2, 4],
>>>                           [2, 3, 4], [3, 0, 4]]

classmethod static_type()

Return the type of surface as stored in a Project.

This can be used for determining if the type of an object is a surface.

associate_raster(raster, registration, desired_index=1)

Associates a raster to the surface using the specified registration.

The RasterRegistration object passed to registration defines how the raster pixels are draped onto the surface.

This edits both the surface and the raster so both objects must be open for read/write to call this function.

Parameters

raster (Raster) – An open raster to associate with the surface.
registration (RasterRegistration) – Registration object to use to associate the raster with the surface. This will be assigned to the raster’s registration property.
desired_index (int) – The desired raster index for the raster. Rasters with higher indices appear on top of rasters with lower indices. This is 1 by default. This must be between 1 and 255 (inclusive).

Returns

The raster index of the associated raster. If the raster is already associated with the object this will be the index given when it was first associated.

Return type

int

Raises

ValueError – If the registration object is invalid.
ValueError – If the raster index cannot be converted to an integer.
ValueError – If the raster index is less than 1 or greater than 255.
ReadOnlyError – If the raster or the surface are open for read-only.
RuntimeError – If the raster could not be associated with the surface.
TypeError – If raster is not a Raster object.
AlreadyAssociatedError – If the Raster is already associated with this object or another object.
NonOrphanRasterError – If the Raster is not an orphan.

Examples

This example shows creating a simple square-shaped surface and associates a raster displaying cyan and white horizontal stripes to cover the surface. In particular note that the call to this function is inside both the with statements for creating the surface and creating the raster. And as the raster is immediately associated with an object there is no need to provide a path for it.

>>> from mapteksdk.project import Project
>>> from mapteksdk.data import Surface, Raster, RasterRegistrationTwoPoint
>>> project = Project()
>>> with project.new("surfaces/simple-rows", Surface) as new_surface:
...     new_surface.points = [[-10, -10, 0], [10, -10, 0],
...                           [-10, 10, 0], [10, 10, 0]]
...     new_surface.facets = [[0, 1, 2], [1, 2, 3]]
...     new_surface.facet_colours = [[200, 200, 0], [25, 25, 25]]
...     with project.new(None, Raster(width=32, height=32
...             )) as new_raster:
...         image_points = [[0, 0], [new_raster.width,
...                                  new_raster.height]]
...         world_points = [[-10, -10, 0], [10, 10, 0]]
...         orientation = [0, 0, 1]
...         new_raster.pixels[:] = 255
...         new_raster.pixels_2d[::2] = [0, 255, 255, 255]
...         registration = RasterRegistrationTwoPoint(
...             image_points, world_points, orientation)
...         new_surface.associate_raster(new_raster, registration)

A raster cannot be associated with more than one surface. Instead, to associate a raster with multiple surfaces the raster must be copied and then the copy is associated with each surface. The below example uses this to create six square surfaces side by side, each with a 2x2 black and white chess board pattern raster applied to them.

>>> from mapteksdk.project import Project
>>> from mapteksdk.data import Surface, Raster, RasterRegistrationTwoPoint
>>> project = Project()
>>> width = 32
>>> height = 32
>>> raster_path = "images/base_raster"
>>> # Create a raster with a path.
>>> with project.new(raster_path, Raster(width=width, height=height
...         )) as base_raster:
...     # This is a 2x2 chess black and white chess board pattern.
...     base_raster.pixels[:] = 255
...     base_raster.pixels_2d[0:16, 0:16] = [0, 0, 0, 255]
...     base_raster.pixels_2d[16:32, 16:32] = [0, 0, 0, 255]
>>> # Create six surfaces each with a copy of the raster applied.
>>> for i in range(6):
...     with project.new(f"checkered_surface_{i}", Surface) as surface:
...         surface.points = [[-10, -10, 0], [10, -10, 0],
...                           [-10, 10, 0], [10, 10, 0]]
...         surface.points[:, 0] += i * 20
...         surface.facets = [[0, 1, 2], [1, 2, 3]]
...         image_points = [[0, 0], [width, height]]
...         world_points = [surface.points[0], surface.points[3]]
...         orientation = [0, 0, 1]
...         registration = RasterRegistrationTwoPoint(
...             image_points, world_points, orientation)
...         # A copy of the raster is associated.
...         raster_id = project.copy_object(raster_path, None)
...         with project.edit(raster_id) as raster:
...             surface.associate_raster(raster, registration)

save()

Save the changes made to the object.

Generally a user does not need to call this function because it is called automatically at the end of a with block using Project.new() or Project.edit().

attribute_names()

Returns a list containing the names of all object-level attributes. Use this to iterate over the object attributes.

Returns: List containing the attribute names.
Return type: list

Examples

Iterate over all object attributes of the object stared at “target” and print their values.

>>> from mapteksdk.project import Project
>>> project = Project()
>>> with project.read("target") as read_object:
...     for name in read_object.attribute_names():
...         print(name, ":", read_object.get_attribute(name))

close(): Closes the object and saves the changes to the Project, preventing any further changes.

property coordinate_system

The coordinate system the points of this object are in.

Warning

Setting this property does not change the points. This is only a label stating the coordinate system the points are in.

Notes

If the object has no coordinate system, this will be None.

Changes are done directly in the project and will not be undone if an error occurs.

Examples

Creating an edge network and setting the coordinate system to be WGS84. Note that setting the coordinate system does not change the points. It is only stating which coordinate system the points are in.

>>> from pyproj import CRS
>>> from mapteksdk.project import Project
>>> from mapteksdk.data import Polygon
>>> project = Project()
>>> with project.new("cad/rectangle", Polygon) as new_edges:
...     # Coordinates are in the form [longitude, latitude]
...     new_edges.points = [[112, 9], [112, 44], [154, 44], [154, 9]]
...     new_edges.coordinate_system = CRS.from_epsg(4326)

Often a standard map projection is not convenient or accurate for a given application. In such cases a local transform can be provided to allow coordinates to be specified in a more convenient system. The below example defines a local transform where the origin is translated 1.2 degrees north and 2.1 degree east, points are scaled to be twice as far from the horizontal origin and the coordinates are rotated 45 degrees clockwise about the horizontal_origin. Note that the points of the polygon are specified in the coordinate system after the local transform has been applied.

>>> import math
>>> from pyproj import CRS
>>> from mapteksdk.project import Project
>>> from mapteksdk.data import Polygon, CoordinateSystem, LocalTransform
>>> project = Project()
>>> transform = LocalTransform(
...     horizontal_origin = [1.2, 2.1],
...     horizontal_scale_factor = 2,
...     horizontal_rotation = math.pi / 4)
>>> system = CoordinateSystem(CRS.from_epsg(20249), transform)
>>> with project.new("cad/rectangle_transform", Polygon) as new_edges:
...     new_edges.points = [[112, 9], [112, 44], [154, 44], [154, 9]]
...     new_edges.coordinate_system = system

See also

mapteksdk.data.coordinate_systems.CoordinateSystem: Allows for a coordinate system to be defined with an optional local transform.

property created_date

The date and time (in UTC) of when this object was created.

Returns: The date and time the object was created. 0:0:0 1/1/1970 if the operation failed.
Return type: datetime.datetime

delete_all_attributes()

Delete all object attributes attached to an object.

This only deletes object attributes and has no effect on PrimitiveAttributes.

Raises: RuntimeError – If all attributes cannot be deleted.

delete_attribute(attribute)

Deletes a single object-level attribute.

Deleting a non-existent object attribute will not raise an error.

Parameters: attribute (str) – Name of attribute to delete.
Returns: True if the object attribute existed and was deleted; False if the object attribute did not exist.
Return type: bool
Raises: RuntimeError – If the attribute cannot be deleted.

delete_edge_attribute(attribute_name)

Delete a edge attribute by name.

Parameters: attribute_name (str) – The name of attribute
Raises: Exception – If the object is opened in read-only mode.

delete_facet_attribute(attribute_name)

Delete a facet attribute by name.

This is equivalent to: facet_attributes.delete_attribute(attribute_name)

Parameters: attribute_name (str) – The name of attribute.
Raises: Exception – If the object is opened in read-only mode.

delete_point_attribute(attribute_name)

Delete a point attribute by name.

This is equivalent to: point_attributes.delete_attribute(attribute_name)

Parameters

attribute_name (str) – The name of attribute

Raises

Exception – If the object is opened in read-only mode.
ValueError – If the primitive type is not supported.

dissociate_raster(raster)

Removes the raster from the object.

This is done directly on the Project and will not be undone if an error occurs.

Parameters: raster (ObjectID or Raster) – The raster to dissociate.
Returns: True if the raster was successfully dissociated from the object, False if the raster was not associated with the object.
Return type: bool
Raises: TypeError – If raster is not a Raster.

Notes

This only removes the association between the Raster and the object, it does not clear the registration information from the Raster.

Examples

Dissociate the first raster found on a picked object.

>>> from mapteksdk.project import Project
>>> from mapteksdk import operations
>>> project = Project()
>>> oid = operations.object_pick(
...     support_label="Pick an object to remove a raster from.")
... with project.edit(oid) as data_object:
...     report = f"There were no raster to remove from {oid.path}"
...     for index in data_object.rasters:
...         data_object.dissociate_raster(data_object.rasters[index])
...         report = f"Removed raster {index} from {oid.path}"
...         break
... # Now that the raster is dissociated and the object is closed,
... # the raster can be associated with a different object.
... operations.write_report("Remove Raster", report)

property edge_attributes

Access to custom edge attributes. These are arrays of values of the same type with one value for each edge.

Use Object.edge_attributes[attribute_name] to access the edge attribute called attribute_name. See PrimitiveAttributes for valid operations on edge attributes.

Returns: Access to the edge attributes.
Return type: PrimitiveAttributes
Raises: ValueError – If the type of the attribute is not supported.

Warning

For Surfaces if you have changed the points or facets in the object, you must call save() before accessing the edge attributes.

property edge_colours

The colours of the edges, represented as a numpy array of RGBA colours, with one colour for each edge. When setting the colour you may use RGB or greyscale colours instead.

If there are more edge colours than edges, the excess colours are silently ignored. If there are fewer colours than edges, the uncoloured edges are coloured green. If only a single colour is passed, instead of padding with green all of the edges are coloured with that colour. ie: object.edge_colours = [[Red, Green, Blue]] will set all edge colours to be the colour [Red, Green, Blue].

property edge_count: The count of edges in the object.

property edge_selection

A 1D ndarray representing which edges are selected.

edge_selection[i] = True indicates edge i is selected.

property edges

A 2D Numpy array of edges of the form: [[i0, j0], [i1, j1], …, [iN, jN]] where N is the number of edges and all iK and jK are valid indices in Object.points.

Warning

For Surfaces the edges are derived from the points and facets. If any changes are made to the points or facets, the corresponding changes to the edges will not be made until save() has been called.

Notes

Invalid edges are removed during save().

property extent: The axes aligned bounding extent of the object.

property facet_attributes

Access the custom facet attributes. These are arrays of values of the same type with one value for each facet.

Use Object.facet_attributes[attribute_name] to access a facet attribute called attribute_name. See PrimitiveAttributes for valid operations on facet attributes.

Returns: Access to the facet attributes.
Return type: PrimitiveAttributes
Raises: ValueError – If the type of the attribute is not supported.

property facet_colours

A 2D numpy array containing the colours of the facets. When setting the colour you may use a list of RGB or greyscale colours.

When facet colours are set, if there are more colours than facets then the excess colours are silently ignored. If there are fewer colours than facets the uncoloured facets are coloured green. If only a single colour is specified, instead of padding with green all of the facets are coloured with that colour. ie: object.facet_colours = [[Red, Green, Blue]] will set all facets to be the colour [Red, Green, Blue].

property facet_count: The number of facets in the object.

property facet_selection

A 1D numpy array representing which facets are selected.

If object.facet_selection[i] = True then the ith facet is selected.

property facets: A 2D numpy array of facets in the object. This is of the form: [[i0, j0, k0], [i1, j1, k1], …, [iN, jN, kN]] where N is the number of facets. Each i, j and k value is the index of the point in Objects.points for the point used to define the facet.

get_attribute(name)

Returns the value for the attribute with the specified name.

Parameters: name (str) – The name of the object attribute to get the value for.
Returns: The value of the object attribute name. For dtype = datetime.datetime this is an integer representing the number of milliseconds since 1st Jan 1970. For dtype = datetime.date this is a tuple of the form: (year, month, day).
Return type: any
Raises: KeyError – If there is no object attribute called name.

Warning

In the future this function may be changed to return datetime.datetime and datetime.date objects instead of the current representation for object attributes of type datetime.datetime or datetime.date.

get_attribute_type(name)

Returns the type of the attribute with the specified name.

Parameters: name (str) – Name of the attribute whose type should be returned.
Returns: The type of the object attribute name.
Return type: type
Raises: KeyError – If there is no object attribute called name.

get_colour_map()

Return the ID of the colour map object currently associated with this object.

Returns: The ID of the colour map object or null object ID if there is no colour map.
Return type: ObjectID

property id

Object ID that uniquely references this object in the project.

Returns: The unique id of this object.
Return type: ObjectID

property lock_type

Indicates whether operating in read-only or read-write mode.

Returns: The type of lock.
Return type: LockType

property modified_date

The date and time (in UTC) of when this object was last modified.

Returns: The date and time this object was last modified. 0:0:0 1/1/1970 if the operation failed.
Return type: datetime.datetime

property point_attributes

Access the custom point attributes. These are arrays of values of the same type with one value for each point.

Use Object.point_attributes[attribute_name] to access the point attribute called attribute_name. See PrimitiveAttributes for valid operations on point attributes.

Returns: Access to the point attributes.
Return type: PrimitiveAttributes
Raises: ValueError – If the type of the attribute is not supported.

property point_colours

The colours of the points, represented as a 2d ndarray of RGBA colours. When setting the colour you may use RGB or greyscale colours instead of RGBA colours. The array has one colour for each point. Object.point_colours[i] returns the colour of Object.points[i].

Notes

When the point colours are set, if there are more colours than points then the excess colours are silently ignored. If there are fewer colours than points then uncoloured points are coloured green. If only a single colour is specified, instead of padding with green all of the points are coloured with that colour. i.e.: object.point_colours = [[Red, Green, Blue]] will set all points to be the colour [Red, Green, Blue].

property point_count: The number of points in the object.

property point_selection

A 1D ndarray representing the point selection.

If Object.point_selection[i] = True then Object.point[i] is selected. Object.point_selection[i] = False then Object.point[i] is not selected.

property point_visibility

A 1D ndarray representing the visibility of points.

Object.point_visibility[i] is true if Object.point[i] is visible. It will be False if the point is invisible.

Object.point_visibility[i] = False will make Object.point[i] invisible.

property point_z

The Z coordinates of the points.

Raises

ValueError – If set using a string which cannot be converted to a float.
ValueError – If set to a value which cannot be broadcast to the right shape.
TypeError – If set using a value which cannot be converted to a float.

property points

A 2D ndarray of points of the form: [[x1, y1, z1], [x2, y2, z2], …, [xN, yN, zN]] Where N is the number of points.

Raises: AttributeError – If attempting to set the points on an object which does not support setting points.

Examples

Create a new point set and set the points:

>>> from mapteksdk.project import Project
>>> from mapteksdk.data import PointSet
>>> project = Project()
... with project.new("cad/test_points", PointSet) as new_points:
...     new_points.points = [[0, 0, 0], [1, 0, 0], [1, 1, 0],
...                          [0, 1, 0], [0, 2, 2], [0, -1, 3]]

Print the second point from the point set defined above.

>>> from mapteksdk.project import Project
>>> from mapteksdk.data import PointSet
>>> project = Project()
>>> with project.read("cad/test_points") as read_points:
...     print(read_points.points[2])
[1., 1., 0.]

Then set the 2nd point to [1, 2, 3]:

>>> from mapteksdk.project import Project
>>> from mapteksdk.data import PointSet
>>> project = Project()
>>> with project.edit("cad/test_points") as edit_points:
...     edit_points.points[2] = [1, 2, 3]

Iterate over all of the points and print them.

>>> from mapteksdk.project import Project
>>> from mapteksdk.data import PointSet
>>> project = Project()
>>> with project.read("cad/test_points") as read_points:
>>>     for point in read_points.points:
>>>         print(point)
[0., 0., 0.]
[1., 0., 0.]
[1., 2., 3.]
[0., 1., 0.]
[0., 2., 2.]
[0., -1., 3.]

Print all points with y > 0 using numpy. Note that index has one element for each point which will be true if that point has y > 0 and false otherwise. This is then used to retrieve the points with y > 0.

>>> from mapteksdk.project import Project
>>> from mapteksdk.data import PointSet
>>> project = Project()
>>> with project.read("cad/test_points") as read_points:
...     index = read_points.points[:, 1] > 0
...     print(read_points.points[index])
[[1. 2. 3.]
 [0. 1. 0.]
 [0. 2. 2.]]

property rasters

A dictionary of raster indices and Object IDs of the raster images currently associated with this object.

The keys are the raster ids and the values are the Object IDs of the associated rasters. Note that all raster ids are integers however they may not be consecutive - for example, an object may have raster ids 0, 1, 5 and 200.

Notes

Rasters with higher indices appear on top of rasters with lower indices. The maximum possible raster id is 255.

Removing a raster from this dictionary will not remove the raster association from the object. Use dissociate_raster to do this.

Examples

Iterate over all rasters on an object and invert the colours. Note that this will fail if there is no object at the path “target” and it will do nothing if no rasters are associated with the target.

>>> from mapteksdk.project import Project
>>> project = Project()
>>> with project.read("target") as read_object:
...     for raster in read_object.rasters.values():
...         with project.edit(raster) as edit_raster:
...             edit_raster.pixels[:, :3] = 255 - edit_raster.pixels[:, :3]

remove_facets(facet_indices, update_immediately=True)

Remove one or more facets. This is done directly in the project and thus changes made by this function will be saved even if save() is not called.

Parameters

facet_indices (array or int) – 1D array of uint32 indices of edges to remove or a single uint32 of index of facet to remove.
update_immediately (bool) – Applies changes to project and re-loads numpy arrays and properties immediately. May be disabled for large datasets.

Returns

True if successful.

Return type

bool

Notes

Immediately reconciling changes on arrays is recommended.

remove_points(point_indices, update_immediately=True)

Remove one or more points. This is done directly in the project and thus changes made by this function will be saved even if save() is not called.

Parameters

point_indices (array_like or int) – The index of the point to remove or a list of indices of points to remove.
update_immediately (bool) – If True, the deletion is done in the Project immediately. If False, the deletion is done when the object is closed.

Returns

True if successful

Return type

bool

Notes

Calling save() immediately after calling this function is recommended.

save_edge_attribute(attribute_name, data)

Create and/or edit the values of the edge attribute attribute_name.

This is equivalent to Object.edge_attributes[attribute_name] = data

Parameters

attribute_name (str) – The name of attribute.
data (array_like) – An array_like of a base type data to store for the attribute per-primitive.

Raises

Exception – If the object is opened in read-only mode.
ValueError – If the type of the attribute is not supported.

save_facet_attribute(attribute_name, data)

Create new and/or edit the values of the facet attribute attribute_name.

This is equivalent to Object.facet_attributes[attribute_name] = data.

Parameters

attribute_name (str) – The name of attribute.
data (array) – A numpy array of a base type data to store for the attribute per-primitive.

save_point_attribute(attribute_name, data)

Create and/or edit the values of the point attribute attribute_name.

This is equivalent to Object.point_attributes[attribute_name] = data.

Parameters

attribute_name (str) – The name of attribute
data (array_like) – An array_like of length point_count containing the values for attribute_name.

Raises

Exception – If the object is opened in read-only mode.
ValueError – If the type of the attribute is not supported.

set_attribute(name, dtype, data)

Sets the value for the object attribute with the specified name. This will overwrite any existing attribute with the specified name.

Parameters

name (str) – The name of the object attribute for which the value should be set.
dtype (type) – The type of data to assign to the attribute. This should be a type from the ctypes module or datetime.datetime or datetime.date. Passing bool is equivalent to passing ctypes.c_bool. Passing str is equivalent to passing ctypes.c_char_p. Passing int is equivalent to passing ctypes.c_int16. Passing float is equivalent to passing ctypes.c_double.
data (any) – The value to assign to object attribute name. For dtype = datetime.datetime this can either be a datetime object or timestamp which will be passed directly to datetime.utcfromtimestamp(). For dtype = datetime.date this can either be a date object or a tuple of the form: (year, month, day).

Raises

ValueError – If dtype is an unsupported type.
TypeError – If value is an inappropriate type for object attribute name.
RuntimeError – If a different error occurs.

Warning

Object attributes are saved separately from the object itself - any changes made by this function (assuming it does not raise an error) will be saved even if save() is not called (for example, due to an error being raised by another function).

Examples

Create an object attribute on an object at “target” and then read its value.

>>> import ctypes
>>> from mapteksdk.project import Project
>>> project = Project()
>>> with project.edit("target") as edit_object:
...     edit_object.set_attribute("count", ctypes.c_int16, 0)
... with project.read("target") as read_object:
...     print(read_object.get_attribute("count"))
0