mrpt.viz

Package Contents

class mrpt.viz.AssimpLoadFlags(value: int)

Members:

RealTimeFast

RealTimeQuality

RealTimeMaxQuality

FlipUVs

IgnoreMaterialColor

Verbose

property name: str

property value: int

FlipUVs: ClassVar[AssimpLoadFlags]

IgnoreMaterialColor: ClassVar[AssimpLoadFlags]

RealTimeFast: ClassVar[AssimpLoadFlags]

RealTimeMaxQuality: ClassVar[AssimpLoadFlags]

RealTimeQuality: ClassVar[AssimpLoadFlags]

Verbose: ClassVar[AssimpLoadFlags]

class mrpt.viz.CAnimatedAssimpModel

C++ API: class mrpt::viz::CAnimatedAssimpModel

Bases: CAssimpModel

getAnimationCount() → int

getAnimationDuration(anim_idx: int = 0) → float

getAnimationName(anim_idx: int) → str

loadScene(file_name: str, flags: int = 4116) → None

setActiveAnimation(anim_name: str) → None

setActiveAnimationByIndex(idx: int) → None

setAnimationTime(t_seconds: float) → None

setLooping(loop: bool) → None

class mrpt.viz.CArrow

C++ API: class mrpt::viz::CArrow

Bases: CVisualObject

setArrowEnds(x0: float, y0: float, z0: float, x1: float, y1: float, z1: float) → None

setHeadRatio(arg0: float) → None

setSmallRadius(arg0: float) → None

class mrpt.viz.CAssimpModel

C++ API: class mrpt::viz::CAssimpModel

Bases: CVisualObject

loadScene(file_name: str, flags: int = 4116) → None

class mrpt.viz.CAxis(xmin: float = -1.0, ymin: float = -1.0, zmin: float = -1.0, xmax: float = 1.0, ymax: float = 1.0, zmax: float = 1.0, frequency: float = 1.0, lineWidth: float = 3.0, marks: bool = True)

C++ API: class mrpt::viz::CAxis

Bases: CVisualObject

enableTickMarks(arg0: bool) → None

getFrequency() → float

getTextScale() → float

setAxisLimits(arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float) → None

setFrequency(arg0: float) → None

setTextScale(arg0: float) → None

class mrpt.viz.CBox

C++ API: class mrpt::viz::CBox

CBox(corner1: mrpt.math.TPoint3D, corner2: mrpt.math.TPoint3D, is_wireframe: bool = False, lineWidth: float = 1.0)

Bases: CVisualObject

enableBoxBorder(arg0: bool) → None

getBoxCorners() → tuple

isWireframe() → bool

setBoxBorderColor(color: mrpt.img.TColor) → None

Color of the box edges, drawn if enableBoxBorder()

setBoxCorners(arg0: mrpt.math.TPoint3D, arg1: mrpt.math.TPoint3D) → None

setWireframe(arg0: bool) → None

class mrpt.viz.CCamera

C++ API: class mrpt::viz::CCamera

Bases: CVisualObject

setAzimuthDegrees(arg0: float) → None

setElevationDegrees(arg0: float) → None

setZoomDistance(arg0: float) → None

class mrpt.viz.CColorBar(colormap: int = 0, width: float = 0.2, height: float = 1.0, min_col: float = 0.0, max_col: float = 1.0, min_value: float = 0.0, max_value: float = 1.0, label_format: str = '%7.02f', label_font_size: float = 0.05000000074505806)

C++ API: class mrpt::viz::CColorBar

Bases: CVisualObject

setColorAndValueLimits(col_min: float, col_max: float, value_min: float, value_max: float) → None

setColormap(colormap: int) → None

class mrpt.viz.CCylinder

C++ API: class mrpt::viz::CCylinder

CCylinder(baseRadius: float, topRadius: float, height: float = 1.0, slices: int = 20)

Bases: CVisualObject

getHeight() → float

setHeight(arg0: float) → None

setRadii(arg0: float, arg1: float) → None

setRadius(arg0: float) → None

class mrpt.viz.CDisk

C++ API: class mrpt::viz::CDisk

CDisk(out_radius: float, in_radius: float, slices: int = 50)

Bases: CVisualObject

property in_radius: float

property out_radius: float

setDiskRadius(out_radius: float, in_radius: float = 0.0) → None

setSlicesCount(N: int) → None

class mrpt.viz.CEllipsoid2D

C++ API: class mrpt::viz::CEllipsoid2D

Bases: CVisualObject

setCovMatrix(arg0: mrpt.math.CMatrixDouble22) → None

setQuantiles(arg0: float) → None

class mrpt.viz.CEllipsoid3D

C++ API: class mrpt::viz::CEllipsoid3D

Bases: CVisualObject

set3DsegmentsCount(arg0: int) → None

setCovMatrix(arg0: mrpt.math.CMatrixDouble33) → None

setQuantiles(arg0: float) → None

class mrpt.viz.CEllipsoidInverseDepth2D

C++ API: class mrpt::viz::CEllipsoidInverseDepth2D

Bases: CVisualObject

getQuantiles() → float

getUnderflowMaxRange() → float

setCovMatrix(arg0: mrpt.math.CMatrixDouble22) → None

setQuantiles(q: float) → None

setUnderflowMaxRange(maxRange: float) → None

class mrpt.viz.CEllipsoidInverseDepth3D

C++ API: class mrpt::viz::CEllipsoidInverseDepth3D

Bases: CVisualObject

getQuantiles() → float

getUnderflowMaxRange() → float

setCovMatrix(arg0: mrpt.math.CMatrixDouble33) → None

setQuantiles(q: float) → None

setUnderflowMaxRange(maxRange: float) → None

class mrpt.viz.CEllipsoidRangeBearing2D

C++ API: class mrpt::viz::CEllipsoidRangeBearing2D

Bases: CVisualObject

getQuantiles() → float

setCovMatrix(arg0: mrpt.math.CMatrixDouble22) → None

setQuantiles(q: float) → None

class mrpt.viz.CFrustum

C++ API: class mrpt::viz::CFrustum

CFrustum(near_distance: float, far_distance: float, horz_FOV_degrees: float, vert_FOV_degrees: float, lineWidth: float = 1.0, draw_lines: bool = True, draw_planes: bool = False)

Bases: CVisualObject

property far_plane: float

property horz_fov: float

property near_plane: float

property vert_fov: float

setHorzFOV(fov_degrees: float) → None

setNearFarPlanes(near: float, far: float) → None

setPlaneColor(color: mrpt.img.TColor) → None

setVertFOV(fov_degrees: float) → None

class mrpt.viz.CGridPlaneXY(xmin: float = -10.0, xmax: float = 10.0, ymin: float = -10.0, ymax: float = 10.0, z: float = 0.0, frequency: float = 1.0)

C++ API: class mrpt::viz::CGridPlaneXY

Bases: CVisualObject

setGridFrequency(arg0: float) → None

setPlaneLimits(xmin: float, xmax: float, ymin: float, ymax: float) → None

setPlaneZcoord(arg0: float) → None

class mrpt.viz.CGridPlaneXZ(xmin: float = -10.0, xmax: float = 10.0, zmin: float = -10.0, zmax: float = 10.0, y: float = 0.0, frequency: float = 1.0)

C++ API: class mrpt::viz::CGridPlaneXZ

Bases: CVisualObject

setGridFrequency(arg0: float) → None

setPlaneLimits(xmin: float, xmax: float, zmin: float, zmax: float) → None

setPlaneYcoord(arg0: float) → None

class mrpt.viz.CMesh(enable_transparency: bool = False, xMin: float = -1.0, xMax: float = 1.0, yMin: float = -1.0, yMax: float = 1.0)

C++ API: class mrpt::viz::CMesh

Bases: CVisualObject

enableColorFromZ(v: bool) → None

Enable color from Z height using HOT colormap

enableTransparency(v: bool) → None

enableWireFrame(v: bool) → None

setGridLimits(xMin: float, xMax: float, yMin: float, yMax: float) → None

setZ(Z: numpy.ndarray) → None

Set height matrix (numpy float32 2D array)

class mrpt.viz.CMesh3D

C++ API: class mrpt::viz::CMesh3D

Bases: CVisualObject

enableFaceNormals(v: bool) → None

enableShowEdges(v: bool) → None

enableShowFaces(v: bool) → None

enableShowVertices(v: bool) → None

loadMesh(vertices: numpy.ndarray, face_vertices: numpy.ndarray, verts_per_face: numpy.ndarray) → None

Load a mesh from numpy arrays: vertices (Nx3 float32), face_vertices (M,) int32, verts_per_face (F,) int32

class mrpt.viz.CMeshFast(enable_transparency: bool = False, xMin: float = -1.0, xMax: float = 1.0, yMin: float = -1.0, yMax: float = 1.0)

C++ API: class mrpt::viz::CMeshFast

Bases: CVisualObject

enableColorFromZ(v: bool, colormap: int = 4) → None

Enable color from Z height (colormap int)

enableTransparency(v: bool) → None

setGridLimits(xmin: float, xmax: float, ymin: float, ymax: float) → None

setZ(Z: numpy.ndarray) → None

Set height matrix (numpy float32 2D array)

class mrpt.viz.COctoMapVoxels

C++ API: class mrpt::viz::COctoMapVoxels

Bases: CVisualObject

clear() → None

enableCubeTransparency(enable: bool) → None

enableLights(enable: bool) → None

getVoxelCount(set_index: int) → int

getVoxelSetCount() → int

push_back_Voxel(set_index: int, x: float, y: float, z: float, side: float, r: int = 200, g: int = 200, b: int = 200, a: int = 255) → None

resizeVoxelSets(n: int) → None

resizeVoxels(set_index: int, n: int) → None

setVisualizationMode(mode: OctoMapVisualizationMode) → None

showGridLines(show: bool) → None

showVoxels(voxel_set: int, show: bool) → None

showVoxelsAsPoints(enable: bool) → None

class mrpt.viz.COrbitCameraController

C++ API: class mrpt::viz::COrbitCameraController

azimuth_deg: float

elevation_deg: float

roll_deg: float

zoom: float

applyTo(cam: CCamera) → None

onMouseButton(x: int, y: int, button: int, down: bool) → None

onMouseMove(x: int, y: int, buttons: int, modifiers: int) → None

onScroll(delta: float, modifiers: int) → None

setAzimuthDegrees(deg: float) → None

setCameraPointing(x: float, y: float, z: float) → None

setElevationDegrees(deg: float) → None

setFrom(cam: CCamera) → None

setZoomDistance(d: float) → None

class mrpt.viz.CPointCloud

C++ API: class mrpt::viz::CPointCloud

Bases: CVisualObject

clear() → None

getPointSize() → float

insertPoint(x: float, y: float, z: float) → None

setPointSize(pointSize: float) → None

Point size, in pixels

setPoints(arg0: numpy.ndarray) → None

class mrpt.viz.CPointCloudColoured

C++ API: class mrpt::viz::CPointCloudColoured

Bases: CVisualObject

clear() → None

getPointSize() → float

push_back(x: float, y: float, z: float, r: float = 1.0, g: float = 1.0, b: float = 1.0, a: float = 1.0) → None

setPointSize(pointSize: float) → None

Point size, in pixels

size() → int

class mrpt.viz.CPolyhedron

C++ API: class mrpt::viz::CPolyhedron

Bases: CVisualObject

static CreateCuboctahedron(radius: float) → CPolyhedron

static CreateDodecahedron(radius: float) → CPolyhedron

static CreateHexahedron(radius: float) → CPolyhedron

static CreateIcosahedron(radius: float) → CPolyhedron

static CreateIcosidodecahedron(radius: float, type: bool = True) → CPolyhedron

static CreateOctahedron(radius: float) → CPolyhedron

static CreateTetrahedron(radius: float) → CPolyhedron

static CreateTruncatedHexahedron(radius: float) → CPolyhedron

static CreateTruncatedIcosahedron(radius: float) → CPolyhedron

static CreateTruncatedOctahedron(radius: float) → CPolyhedron

static CreateTruncatedTetrahedron(radius: float) → CPolyhedron

class mrpt.viz.CSetOfLines

C++ API: class mrpt::viz::CSetOfLines

Bases: CVisualObject

appendLine(x0: float, y0: float, z0: float, x1: float, y1: float, z1: float) → None

appendLine(arg0: mrpt.math.TSegment3D) → None

clear() → None

class mrpt.viz.CSetOfObjects

C++ API: class mrpt::viz::CSetOfObjects

Bases: CVisualObject

clear() → None

insert(obj: CVisualObject) → None

class mrpt.viz.CSetOfTexturedTriangles

C++ API: class mrpt::viz::CSetOfTexturedTriangles

Bases: CVisualObject

clearTriangles() → None

getTriangle(idx: int) → TTriangle

getTrianglesCount() → int

insertTriangle(triangle: TTriangle) → None

class mrpt.viz.CSetOfTriangles

C++ API: class mrpt::viz::CSetOfTriangles

Bases: CVisualObject

clearTriangles() → None

getTriangle(idx: int) → TTriangle

getTrianglesCount() → int

insertTriangle(triangle: TTriangle) → None

class mrpt.viz.CSimpleLine

C++ API: class mrpt::viz::CSimpleLine

Bases: CVisualObject

getLineEnd() → mrpt.math.TPoint3Df

getLineStart() → mrpt.math.TPoint3Df

setLineCoords(x0: float, y0: float, z0: float, x1: float, y1: float, z1: float) → None

class mrpt.viz.CSkyBox

C++ API: class mrpt::viz::CSkyBox

Bases: CVisualObject

assignImage(face: CubeTextureFace, img: mrpt.img.CImage) → None

class mrpt.viz.CSphere(radius: float = 1.0, nDivs: int = 20)

C++ API: class mrpt::viz::CSphere

Bases: CVisualObject

getRadius() → float

setNumberDivs(arg0: int) → None

setRadius(arg0: float) → None

class mrpt.viz.CText

C++ API: class mrpt::viz::CText

CText(text: str)

Bases: CVisualObject

getString() → str

setFont(arg0: str, arg1: int) → None

setString(arg0: str) → None

class mrpt.viz.CText3D(text: str = '', fontName: str = 'sans', scale: float = 1.0)

C++ API: class mrpt::viz::CText3D

Bases: CVisualObject

getString() → str

setString(arg0: str) → None

class mrpt.viz.CTexturedPlane(x_min: float = -1.0, x_max: float = 1.0, y_min: float = -1.0, y_max: float = 1.0)

C++ API: class mrpt::viz::CTexturedPlane

Bases: CVisualObject

enableLighting(enable: bool = True) → None

getPlaneCorners() → tuple

setPlaneCorners(xMin: float, xMax: float, yMin: float, yMax: float) → None

setTextureRepeat(repeatX: float, repeatY: float) → None

class mrpt.viz.CVectorField2D

C++ API: class mrpt::viz::CVectorField2D

Bases: CVisualObject

clear() → None

setGridCenterAndCellSize(cx: float, cy: float, cell_x: float, cell_y: float) → None

setGridLimits(xmin: float, xmax: float, ymin: float, ymax: float) → None

setPointColor(R: float, G: float, B: float, A: float = 1.0) → None

setVectorField(vx: Any, vy: Any) → None

setVectorFieldColor(R: float, G: float, B: float, A: float = 1.0) → None

class mrpt.viz.CVectorField3D

C++ API: class mrpt::viz::CVectorField3D

Bases: CVisualObject

clear() → None

setMaxSpeedForColor(s: float) → None

setPointColor(R: float, G: float, B: float, A: float = 1.0) → None

setPointCoordinates(px: Any, py: Any, pz: Any) → None

setVectorField(vx: Any, vy: Any, vz: Any) → None

setVectorFieldColor(R: float, G: float, B: float, A: float = 1.0) → None

class mrpt.viz.CubeTextureFace(value: int)

Members:

LEFT

RIGHT

TOP

BOTTOM

FRONT

BACK

property name: str

property value: int

BACK: ClassVar[CubeTextureFace]

BOTTOM: ClassVar[CubeTextureFace]

FRONT: ClassVar[CubeTextureFace]

LEFT: ClassVar[CubeTextureFace]

RIGHT: ClassVar[CubeTextureFace]

TOP: ClassVar[CubeTextureFace]

class mrpt.viz.OctoMapVisualizationMode(value: int)

Members:

FIXED : All voxels have the same fixed color

COLOR_FROM_HEIGHT : Color voxels by height

COLOR_FROM_OCCUPANCY : Color by occupancy probability

TRANSPARENCY_FROM_OCCUPANCY : Transparency from occupancy

TRANS_AND_COLOR_FROM_OCCUPANCY : Both transparency and color from occupancy

COLOR_FROM_RGB_DATA : Use per-voxel stored RGB

property name: str

property value: int

COLOR_FROM_HEIGHT: ClassVar[OctoMapVisualizationMode]

COLOR_FROM_OCCUPANCY: ClassVar[OctoMapVisualizationMode]

COLOR_FROM_RGB_DATA: ClassVar[OctoMapVisualizationMode]

FIXED: ClassVar[OctoMapVisualizationMode]

TRANSPARENCY_FROM_OCCUPANCY: ClassVar[OctoMapVisualizationMode]

TRANS_AND_COLOR_FROM_OCCUPANCY: ClassVar[OctoMapVisualizationMode]

class mrpt.viz.Scene

C++ API: class mrpt::viz::Scene

clear(createMainViewport: bool = True) → None

Removes all objects (and viewports), then re-creates the main viewport

createViewport(name: str) → Viewport

getViewport(name: str = 'main') → Viewport

insert(arg0: CVisualObject) → None

class mrpt.viz.TLight

C++ API: struct mrpt::viz::TLight

attenuation_constant: float

attenuation_linear: float

attenuation_quadratic: float

diffuse: float

direction: mrpt.math.TPoint3Df

position: mrpt.math.TPoint3Df

specular: float

spot_inner_cutoff_deg: float

spot_outer_cutoff_deg: float

type: TLightType

static Directional(dir: mrpt.math.TPoint3Df, r: float = 1.0, g: float = 1.0, b: float = 1.0, diffuse: float = 0.800000011920929, specular: float = 0.949999988079071) → TLight

class mrpt.viz.TLightType(value: int)

Members:

Directional

Point

Spot

property name: str

property value: int

Directional: ClassVar[TLightType]

Point: ClassVar[TLightType]

Spot: ClassVar[TLightType]

class mrpt.viz.TTriangle

C++ API: struct mrpt::viz::TTriangle

TTriangle(p1: mrpt.math.TPoint3Df, p2: mrpt.math.TPoint3Df, p3: mrpt.math.TPoint3Df)

vertices: list[TTriangleVertex]

computeNormals() → None

class mrpt.viz.TTriangleVertex

setColor(color: mrpt.img.TColor) → None

Set vertex color from TColor

class mrpt.viz.Viewport

C++ API: class mrpt::viz::Viewport

property name: str

clear() → None

getCamera() → Any

insert(obj: CVisualObject) → None

setCustomBackgroundColor(arg0: mrpt.img.TColorf) → None

setViewportPosition(arg0: float, arg1: float, arg2: float, arg3: float) → None

mrpt.viz.create_point_cloud(pts_array, color=(255, 255, 255))

mrpt.viz.posePDF2opengl(pdf: mrpt.poses.CPosePDF) → CSetOfObjects

mrpt.viz.posePDF2opengl(pdf: mrpt.poses.CPose3DPDF) → CSetOfObjects

Returns a 3D representation of a 3D pose PDF (ellipsoids, particles, …)