Namespace AIAC¶

Namespace List > AIAC

Namespaces¶

Classes¶

Public Types¶

Public Attributes¶

Public Static Attributes¶

Public Functions¶

Public Static Functions¶

Public Types Documentation¶

enum ACIMState¶

enum AIAC::ACIMState {
    NOT_DONE,
    CURRENT,
    DONE
};

enum ACToolHeadType¶

All the possible types of the toolheads in AC.

enum AIAC::ACToolHeadType {
    DRILLBIT,
    CIRCULARSAW,
    SABERSAW,
    CHAINSAW
};

holding the data of the toolheads from .acit and the corresponding GOs¶

typedef EQ¶

using AIAC::EQ = typedef eventpp::EventQueue<EventType, void(const EventPointer&), EventPolicy>;

enum EventCategory¶

enum AIAC::EventCategory {
    None = 0,
    EventCategoryApplication =              BIT(0),
    EventCategorySLAM =                     BIT(1),
    EventCategoryCamera =                   BIT(2)
};

typedef EventPointer¶

using AIAC::EventPointer = typedef std::shared_ptr<Event>;

enum EventType¶

enum AIAC::EventType {
    None = 0,
    AppClose,
    SLAMMapLoaded,
    SLAMVocabularyLoaded,
    SLAMStartMapping,
    SLAMStopMapping,
    SLAMCombineMapEvent,
    CameraCalibrationLoaded
};

enum GLObjectType¶

enum AIAC::GLObjectType {
    POINTS,
    LINES,
    TRIANGLES
};

enum GOTypeFlags¶

enum AIAC::GOTypeFlags {
    _GOPrimitive = 0,
    _GOPoint,
    _GOLine,
    _GOCircle,
    _GOCylinder,
    _GOPolyline,
    _GOTriangle,
    _GOMesh,
    _GOText
};

enum ImageFormat¶

Enum representing different image formats.

enum AIAC::ImageFormat {
    None = 0,
    RGB,
    RGBA,
    GRAYSCALE
};

typedef Ref¶

using AIAC::Ref = typedef std::shared_ptr<T>;

typedef Scope¶

using AIAC::Scope = typedef std::unique_ptr<T>;

Public Attributes Documentation¶

variable VertexArrayID¶

GLuint AIAC::VertexArrayID;

Public Static Attributes Documentation¶

variable CUT_EDGE_COLOR¶

std::map<ACIMState, glm::vec4> AIAC::CUT_EDGE_COLOR;

variable CUT_FACE_COLOR¶

std::map<ACIMState, glm::vec4> AIAC::CUT_FACE_COLOR;

variable HOLE_AXIS_COLOR¶

std::map<ACIMState, glm::vec4> AIAC::HOLE_AXIS_COLOR;

variable HOLE_CYLINDER_COLOR¶

std::map<ACIMState, glm::vec4> AIAC::HOLE_CYLINDER_COLOR;

variable OGL_BLACK¶

const glm::vec4 AIAC::OGL_BLACK;

variable OGL_BLUE¶

const glm::vec4 AIAC::OGL_BLUE;

variable OGL_CYAN¶

const glm::vec4 AIAC::OGL_CYAN;

variable OGL_GREEN¶

const glm::vec4 AIAC::OGL_GREEN;

variable OGL_MAGENTA¶

const glm::vec4 AIAC::OGL_MAGENTA;

variable OGL_RED¶

const glm::vec4 AIAC::OGL_RED;

variable OGL_WHITE¶

const glm::vec4 AIAC::OGL_WHITE;

variable OGL_YELLOW¶

const glm::vec4 AIAC::OGL_YELLOW;

variable WEIGHT_TO_CYLINDER_RADIUS_RATE¶

const float AIAC::WEIGHT_TO_CYLINDER_RADIUS_RATE;

variable s_CursorPos¶

struct AIAC::Position AIAC::s_CursorPos;

variable s_GLFWWindowCount¶

uint8_t AIAC::s_GLFWWindowCount;

variable s_IsMouseButtonPressed¶

bool AIAC::s_IsMouseButtonPressed;

Public Functions Documentation¶

function CaptureFramePixels¶

std::vector< GLubyte > AIAC::CaptureFramePixels (
    const ApplicationSpecification & appSpec
) 

function CreateCircle¶

std::vector< std::shared_ptr< GLObject > > AIAC::CreateCircle (
    glm::vec3 center,
    glm::vec3 normal,
    float radius,
    glm::vec4 color,
    glm::vec4 edgeColor,
    float edgeWeight,
    int sectorNum
) 

function CreateCylinder¶

std::vector< std::shared_ptr< GLObject > > AIAC::CreateCylinder (
    const glm::vec3 & baseCenter,
    const glm::vec3 & topCenter,
    GLfloat radius,
    glm::vec4 color,
    glm::vec4 edgeColor,
    int sectorNum
) 

function CreatePolyline¶

std::vector< std::shared_ptr< GLObject > > AIAC::CreatePolyline (
    std::vector< glm::vec3 > vertices,
    bool isClosed,
    glm::vec4 color,
    float lineWidth
) 

function CreateRef¶

template<typename T, typename ... Args>
constexpr Ref< T > AIAC::CreateRef (
    Args &&... args
) 

function CreateScope¶

template<typename T, typename ... Args>
constexpr Scope< T > AIAC::CreateScope (
    Args &&... args
) 

function CvtCvMat2GlTextureObj¶

Convert OpenCV matrix to OpenGL texture object.

void AIAC::CvtCvMat2GlTextureObj (
    cv::Mat & cvMat,
    GLuint & glTextureObj,
    GLint glInternalFormat=GL_RGB
) 

Parameters:

• cvMat OpenCV matrix.
• glTextureObj OpenGL texture object.
• glInternalFormat Internal format of the OpenGL texture.

function CvtCvMat2ImTexture¶

Convert cv::Mat to ImTexture , a glTextureObj is required as a texture holder.

void AIAC::CvtCvMat2ImTexture (
    cv::Mat & cvMat,
    ImTexture & imTexture,
    GLuint & glTextureObj,
    GLint glInternalFormat
) 

Convert OpenCV matrix to ImGui texture.

Parameters:

• imTexture The output ImTexture.
• glTextureObj The texture holder. Remember to delete it with glDeleteTextures(1, &glTextureObj)
• cvMat OpenCV matrix.
• imTexture ImGui texture.
• glTextureObj OpenGL texture object.
• glInternalFormat Internal format of the OpenGL texture.

function CvtGlTextureObj2ImTexture¶

Convert OpenGL texture object to ImGui texture.

void AIAC::CvtGlTextureObj2ImTexture (
    GLuint glTextureID,
    ImTexture & imTexture,
    ImVec2 size=ImVec2(0, 0)
) 

Parameters:

• glTextureID OpenGL texture ID.
• imTexture ImGui texture.
• size Size of the texture.

function DrawAllGOs¶

Draw all the GOs present in the GORegistry .

void AIAC::DrawAllGOs (
    glm::mat4 projection=glm::mat4(1.0f),
    float textScale=1.0f
) 

Parameters:

• projection OpenGL projection matrix.

function DrawCircle¶

Draw a single circle.

void AIAC::DrawCircle (
    glm::vec3 center,
    glm::vec3 normal,
    float radius,
    glm::vec4 color,
    glm::vec4 edgeColor,
    float edgeWeight,
    int sectorNum=24
) 

Parameters:

• center Center of the circle.
• normal The normal of plane on which the circle lays.
• radius Radius of the circle.
• color RGBA Color of the face.
• edgeColor RGBA Color of the edge.
• edgeWeight Weight of the edge.
• sectorNum Number of sectors, can be derived from GetSectorNum(radius).

function DrawCircle¶

void AIAC::DrawCircle (
    const GOCircle & goCircle
) 

function DrawCircles¶

void AIAC::DrawCircles (
    const std::vector< std::shared_ptr< GOCircle >> & goCircles
) 

function DrawCylinder¶

Draw a Cylinder, this is also used for drawing lines with heavy weight (>1.0f).

void AIAC::DrawCylinder (
    const glm::vec3 & baseCenter,
    const glm::vec3 & topCenter,
    GLfloat radius,
    glm::vec4 color,
    glm::vec4 edgeColor,
    int sectorNum=24
) 

Parameters:

• baseCenter Base center (bottom) of the cylinder.
• topCenter Top center (top) of the cylinder.
• radius Radius of the cylinder; For drawing line, radius = weight * WEIGHT_TO_CYLINDER_RADIUS_RATE.
• color Color of the cylinder.
• edgeColor The color of the edges of the caps.
• sectorNum Number of sectors of the cylinder. Can call GetSectorNum(radius) to get the default value.

function DrawCylinder¶

void AIAC::DrawCylinder (
    const GOCylinder & goCylinder
) 

function DrawCylinders¶

void AIAC::DrawCylinders (
    const std::vector< std::shared_ptr< GOCylinder >> & goCylinders
) 

function DrawGO¶

Draw a GOPrimitive . (This function neglects the "isVisible" attribute of the object and will draw it anyway)

void AIAC::DrawGO (
    const shared_ptr< GOPrimitive > & goPrimitive
) 

Parameters:

• goPrimitive Object to draw.

function DrawLine¶

Draw a line on two glm::vec3.

void AIAC::DrawLine (
    const glm::vec3 & p1,
    const glm::vec3 & p2,
    float weight=GOWeight::Default,
    const glm::vec4 & color=glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)
) 

Parameters:

• p1 First point.
• p2 Second point.
• weight Weight of the line.
• color RGBA Color of the line.

function DrawLine¶

void AIAC::DrawLine (
    const GOLine & goLine
) 

function DrawLines¶

Draw multiple lines.

void AIAC::DrawLines (
    const vector< glm::vec3 > & vertices,
    float weight,
    const glm::vec4 & color
) 

Parameters:

• vertices A vector of glm::vec3. If you have line [p1, p2] and [p2, p3], the vector should be construct as [p1, p2, p2, p3, ...]
• weight Weight of the line.
• color RGBA Color of the line.

function DrawLines¶

void AIAC::DrawLines (
    const std::vector< std::shared_ptr< GOLine >> & goLines
) 

function DrawMesh¶

void AIAC::DrawMesh (
    const GOMesh & goMesh
) 

function DrawMeshes¶

void AIAC::DrawMeshes (
    const std::vector< std::shared_ptr< GOMesh >> & goMeshes
) 

function DrawPoint¶

Draw a GOPoint .

void AIAC::DrawPoint (
    const GOPoint & goPoint
) 

Parameters:

• goPoint The point to draw.

function DrawPoints¶

void AIAC::DrawPoints (
    const std::vector< std::shared_ptr< GOPoint >> & goPoints
) 

function DrawPolyline¶

void AIAC::DrawPolyline (
    const GOPolyline & goPolyline
) 

function DrawPolylines¶

void AIAC::DrawPolylines (
    const std::vector< std::shared_ptr< GOPolyline >> & goPolylines
) 

function DrawSlamMap¶

Draw TSlam map.

void AIAC::DrawSlamMap (
    const std::shared_ptr< tslam::Map > & map,
    const glm::vec4 & color,
    float pointSize=1
) 

Parameters:

• map A TSlam map
• color The color of the point cloud

function DrawSlamMap¶

Render Slam map on the current frame.

void AIAC::DrawSlamMap (
    const shared_ptr< tslam::Map > & map,
    const glm::vec4 & color,
    float pointSize
) 

Parameters:

• map A tslam map to be rendered.
• color PointCloud's color.
• pointSize PointCloud's size.

function DrawText¶

void AIAC::DrawText (
    const GOText & goText,
    float scale,
    const glm::mat4 & projection
) 

function DrawTexts¶

void AIAC::DrawTexts (
    const std::vector< std::shared_ptr< GOText >> & goTexts,
    float scale,
    const glm::mat4 & projection
) 

function DrawTexts¶

void AIAC::DrawTexts (
    std::vector< GOText > goTexts,
    float scale=1.0f,
    const glm::mat4 & projection=glm::mat4(1.0f)
) 

function DrawTriangle¶

void AIAC::DrawTriangle (
    const GOTriangle & goTriangle
) 

function DrawTriangles¶

void AIAC::DrawTriangles (
    const std::vector< std::shared_ptr< GOTriangle >> & goTriangles
) 

function GetRigidTransformationMatrix¶

Get the rigid transformation matrix from two correlated set of 3D points @praam srcPts The source points.

glm::mat4x4 AIAC::GetRigidTransformationMatrix (
    std::vector< glm::vec3 > srcPts,
    std::vector< glm::vec3 > dstPts
) 

Parameters:

• dstPts The destination points

function GetRotationMatrix¶

Get the rotation matrix associated with counterclockwise rotation about the given axis by theta radians.

glm::mat3x3 AIAC::GetRotationMatrix (
    glm::vec3 axis,
    float theta
) 

Parameters:

• axis The axis of rotation.
• theta The angle of rotation in radians.

Returns:

The rotation matrix.

function GetSectorNum¶

int AIAC::GetSectorNum (
    float radius
) 

function GetTransformed¶

Combine 3 points into a glm::vec3 and transform it based on the given transformation matrix.

glm::vec3 AIAC::GetTransformed (
    glm::mat4 transformMat,
    float x,
    float y,
    float z
) 

Parameters:

• transformMat A 4x4 transformation matrix.
• x X coordinate.
• y Y coordinate.
• z Z coordinate.

function GetTranslationMatrix¶

Get the translation matrix associated with the given translation vector.

glm::mat4x4 AIAC::GetTranslationMatrix (
    glm::vec3 translationVector
) 

Parameters:

• translationVector The translation vector

Returns:

The translation matrix

function StringToBool¶

Convert a string to bool.

bool AIAC::StringToBool (
    std::string str
) 

Parameters:

• str string

Returns:

bool

function StringToSet¶

Convert a string separated by space to a set of tokens.

std::set< std::string > AIAC::StringToSet (
    std::string str
) 

Parameters:

• str string separated by space

Returns:

a std::set<std::string>

function StringToState¶

Convert string m_State to ACIMState.

ACIMState AIAC::StringToState (
    std::string m_State
) 

Parameters:

• m_State ACIMState

function StringToTokens¶

Convert a string separated by space to a list of string.

std::vector< std::string > AIAC::StringToTokens (
    std::string str
) 

Parameters:

• str string separated by space

Returns:

a std::vector<std::string>

function StringToVec3¶

Convert a string separated by space to glm::vec3.

glm::vec3 AIAC::StringToVec3 (
    std::string str
) 

Parameters:

• str string separated by space

Returns:

glm::vec3

function Vec3ToString¶

Convert a vec3 to String.

std::string AIAC::Vec3ToString (
    glm::vec3 vec3
) 

Parameters:

• vec3 vec3

Returns:

string

function glDrawLines3d¶

Draw multiple points.

void AIAC::glDrawLines3d (
    const std::vector< glm::vec3 > & edges,
    const std::vector< glm::vec4 > & colors
) 

Draw multiple lines

(0, 1, 0) (1, 0, 0) || |-----| ||

(0, 0, 0) (0, 0, 1)

If you want to draw a square like this, you should construct the edges as: [ (0, 0, 0), (0, 0, 1), (0, 0, 1), (1, 0, 0), (1, 0, 0), (0, 1, 0), (0, 1, 0), (0, 0, 0) ]

Parameters:

• vertices A vector of 3d points, indicate the position of the vertices.
• colors A RGBA(0~1.0) color, a vector with the same size of the vertices.

function glDrawLines3d¶

Draw multiple points.

void AIAC::glDrawLines3d (
    const std::vector< glm::vec3 > & edges,
    const glm::vec4 & color
) 

Parameters:

• vertices A vector of 3d points, indicate the position of the vertices.
• colors A RGBA(0~1.0) color.

function glDrawPoints3d¶

Draw multiple points.

void AIAC::glDrawPoints3d (
    const std::vector< glm::vec3 > & vertices,
    const std::vector< glm::vec4 > & colors,
    GLfloat pointSize=1.0f
) 

Parameters:

• vertices A vector of 3d points, indicate the position of the vertices.
• colors A RGBA(0~1.0) color, a vector with the same size of the vertices.
• pointSize The size of the point.

function glDrawPoints3d¶

Draw multiple points.

void AIAC::glDrawPoints3d (
    const std::vector< glm::vec3 > & vertices,
    const glm::vec4 & color,
    GLfloat pointSize=1.0f
) 

Parameters:

• vertices A vector of 3d points, indicate the position of the vertices.
• colors A RGBA(0~1.0) color.
• pointSize The size of the point.

function glDrawTriangles3d¶

Draw multiple Triangles.

void AIAC::glDrawTriangles3d (
    const std::vector< glm::vec3 > & vertices,
    const std::vector< uint32_t > & indices,
    const std::vector< glm::vec4 > & colors
) 

P2(0, 1, 0) P3(1, 0, 0) | / | | / | | / | | / | | / | P0(0, 0, 0) P1(0, 0, 1)

If you want to draw a mesh of square like this, you should construct the edges as: [ (0, 0, 0), // P0 (0, 0, 1), // P1 (1, 0, 0), // P2 (0, 1, 0), // P3 ] with indices: [ 0, 1, 3, // Right-bottom triangle 3, 2, 0 // Left-top triangle ]

Parameters:

• vertices A vector of 3d points, indicate the position of the vertices.
• indices A vector of all triangle's indices.
• colors A RGBA(0~1.0) color, a vector with the same size of the vertices.

function glDrawTriangles3d¶

Draw multiple Triangles.

void AIAC::glDrawTriangles3d (
    const std::vector< glm::vec3 > & vertices,
    const std::vector< uint32_t > & indices,
    const glm::vec4 & colors
) 

Parameters:

• vertices A vector of 3d points, indicate the position of the vertices.
• indices A vector of all triangle's indices.
• colors A RGBA(0~1.0) color, a vector with the same size of the vertices.

function operator>>¶

void AIAC::operator>> (
    cv::VideoCapture cap,
    AIAC::Image & img
) 

Public Static Functions Documentation¶

function GLFWErrorCallback¶

static void AIAC::GLFWErrorCallback (
    int error,
    const char * description
) 

function GLFWMonitorCallback¶

static void AIAC::GLFWMonitorCallback (
    GLFWmonitor * monitor,
    int event
) 

function IsGlfwInitialized¶

static bool AIAC::IsGlfwInitialized () 

The documentation for this class was generated from the following file src/AIAC/ACInfoModel.cpp