h1. %{color: darkred } Types of items available in Computree% |{width: 4000px;text-align:left;border-color:transparent}. !/attachments/download/19/fr_FR.png! [[Fr_datatypes|...version française de cette page ]]| p<>. *Computree* includes items of different types, to manage different types of data necessary for the algorithms developed. A number of standard types of items are available in the *core*, what allow compatibility between plugins. notice<>. However, if necessary, a plugin can define specific types of items, used solely by this plugin. h1. Points managment and corresponding types of items p<>. *Computree* is designed to handle 3D point clouds. As such points have a specific place in the platform. And points (class _CT_Point_) are not items to optimize the memory management. tip<>. Classes in Computree are prefixed by a code to determine their membership plugin. _CT_ Prefix means that the class is implemented in the core of Computree. p<>. A point is simply an array of three decimal numbers (float, 7 significant digits) containing its coordinates (x , y, z). All points created in a session are grouped in a *points repository* and indexed continuously. warning<>. To date, the use of float decimal type (for memory optimization purposes) poses problems when point clouds are projected in geographic coordinates such as Lambert 93, due to the large number of significant digits needed. In these cases there will be loss of precision when importing points in *Computree*. At the moment, it is best to work in sensor geometry (scan center (0,0,0)). {TODO} It is expected in the short term to integrate a system of coordinates offsets to avoid this problem . This will be particularly necessary for the use of aerial LiDAR data. p<>. To manage / display the points, they are managed within "containing points items", which inheriting the class _CT_AbstractItemDrawableWithPointCloud_. p<>. There are two types of items like this so far: * The *scenes* (class _CT_Scene_) designed to manage point clouds of important size, optimizing memory usage of indexes. In the case of a scene, points are added all at once during the creation. * The *clusters* (class _CT_PointCluster_) are rather adapted to the management of "small" sets of points (even if there is no defined limit to the number of points in a cluster). In this case the items may be added successively during the processing. Moreover, clusters update their centroid (which are displayable) in real-time.x notice<>. It is possible to have generic algorithms that can use either any type of derivative _CT_AbstractItemDrawableWithPointCloud_ item. h1. Meshes p<>. On the same model as points, *Computree* can handle meshes. A mesh is constituted of *points*, *faces* and *half edges*. Each of these elements is operated similarly to the point (they are not items). There is therefore a repository of faces and a repository of *half-edges*. p<>. As for points, there is a type of item managing the arrangement of points, faces and half-edges : the *mesh model* (class _CT_MeshModel_ ). It will manage the construction, modification and display of individual elements of the mesh. h1. Attributes p<>. We discussed about the items for storing 3D information for points, faces and half-edges. However, data associated with these elements, such as intensity, color or normal are frequently used. p<>. So there are types of items responsible for storing the information related to the mentioned elements: the *attributes*. p<>. There is an item type attribute for each crossing *type of data* / *element type*. p<>. To date, *Computree handle* following types of attributes: * *Scalar Attributes*: A value is attached to each element. The value type (integer, float, boolean) is specified as a _template_. Items scalar attributes belong to classes of items _CT_PointsAttributesScalarTemplated_, _CT_FaceAttributesScalarTemplated_ and _CT_EdgeAttributesScalarTemplated_ respectively for points, faces and half-edges. * *Colors*: For each element, a color is defined by 4 integer values, between 0 and 255 (red, green, blue, alpha = transparency). Items color attributes belong to classes of items _CT_PointsAttributesColor_, _CT_FaceAttributesColor_ and _CT_EdgeAttributesColor_ respectively for points, faces and half-edges. * *Normals* / *Curvature*: for each element 4 decimal numbers are stored (float): the vector of normal direction (dx, dy, dz ) and the curvature. Items *Normals* / *Curvature* attributes belong to classes of items _CT_PointsAttributesNormal_, _CT_FaceAttributesNormal_ and _CT_EdgeAttributesNormal_ respectively for points, faces and half-edges. h1. Geometric shapes p<>. *Computree* offers a variety of types of items to manage 3D geometric shapes on a common logic. p<>. Thus there is a type of item for each geometric shape, inheriting all of the class _CT_AbstractShape_: * *Circles* (class _CT_Circle_): a center (x, y, x), a normalized direction (x, y , z) * *Ellipses* (class _CT_Ellipse_): a center (x, y, x), a normalized direction (x , y, z), a small radius and a large radius * *Cylinders* (class _CT_Cylinder_): a center (x, y, x), a normalized direction (x , y, z), a radius and an height * *Lines* (class _CT_Line_), which consist of two segments ends ( x , y, z ) * *Polygon 2D* (class _CT_Polygon2D_): a list of ordered vertices in horizontal plane {TODO} It is expected in the medium term to add other geometric shapes : 3D polygon, rectangle, cube, cone, bezier curves... h1. Data grids *Computree* offers two types of item to manage data in a "grid": * The *2D grids* (class _CT_Grid2D_) to manage grids in two dimensions or *raster*. These items contain a two-dimensional table, each cell containing a value. * The *3D grids* (class _CT_Grid3D_) to manage grids in three dimensions or *voxels grid*. These items contain a three-dimensional table, each cell containing a value. p<>. These classes of items are *templates*, so they can be declined for various types of data in the cells. tip<>. For example, voxels containing interger would be of class _CT_Grid3D_. p<>. These structures are working in a very similar way. It handle missing values (except in the case of booleans). h1. Other types of items p<>. There exist more types of items for specific uses: * The *scanner position* (class _CT_Scanner_) store the position and parameters of a T- Lidar scan. * The *beam* (class _CT_Beam_) manage a laser beam emitted from a scanner. _____ |[[En_introduction|Previous page(General Presentation)]]|[[En_overview|Back to summary]]|[[En_computreeGUI|Next (Standard Graphic Interface)]]|