OpenFlipper

https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/
Admin
OpenFlipper is a flexible geometry modeling and processing system that uses a core application and a...
Tokens:7,596,203
Snippets:52,869
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### OpenMesh Tutorials (Code Examples)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/mesh_iterators

A collection of tutorials and code examples demonstrating various aspects of OpenMesh. These examples serve as practical guides for implementing mesh processing tasks.

```text
Tutorials (code examples)
```

--------------------------------

### Install OpenVolumeMesh

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/building_openvolumemesh

This command installs the OpenVolumeMesh library and its header files into the system's default include and lib directories (e.g., /usr/local/include and /usr/local/lib). 'sudo' is typically required for installation.

```bash
sudo make install

```

--------------------------------

### Process Setup and Thread Creation

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/processInterfacePage

Demonstrates how to instantiate an OpenFlipperThread, start a job with the process manager, and connect signals for thread management.

```APIDOC
## Process Setup

### Description
Instantiate an `OpenFlipperThread` and inform the core about its creation using `ProcessInterface::startJob()`.

### Method
N/A (C++ Code Example)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```cpp
// Create job named "My Thread". This name will be visible in OpenFlipper's process manager.
OpenFlipperThread* thread = new OpenFlipperThread(name() + "My thread");

// Inform OpenFlipper about the newly created job.
// The parameters include the job name, a description, the start and end values for steps (for progress bar), and a boolean indicating if the job is non-blocking.
// The last parameter 'false' means the job is non-blocking, keeping the UI responsive.
emit startJob( name() + "My thread", "My thread's description", 0, 100, false);

// Connect the thread's 'finished' signal to the plugin's 'finishJob' signal.
// This informs the core when the thread has completed its execution.
connect(thread, SIGNAL(finished(QString)), this, SIGNAL(finishJob(QString)));

// Connect the thread's 'function' signal to a local slot (e.g., testFunctionThread).
// This slot will contain the code to be executed within the thread.
// The 'jobId' (thread name) is passed to the slot for potential UI control (like progress updates).
connect(thread, SIGNAL(function(QString)), this, SLOT(testFunctionThread(QString)), Qt::DirectConnection);
```

### Response
N/A
```

--------------------------------

### OpenMesh Tutorials: Building a Cube

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/tutorial_10

This tutorial guides developers through the process of building a simple cube using the OpenMesh library. It serves as a fundamental example for understanding mesh creation and manipulation.

```C++
#include <OpenMesh/Core/IO/MeshIO.hh>
#include <OpenMesh/Core/Mesh/TriMesh.hh>

// Define your mesh type
typedef OpenMesh::TriMesh_ArrayKernelT<...> MyMesh;

int main(int argc, char** argv)
{
    MyMesh mesh;

    // Add vertices for a cube
    MyMesh::VertexHandle vhandle[8];
    vhandle[0] = mesh.new_vertex(MyMesh::Point(0, 0, 0));
    vhandle[1] = mesh.new_vertex(MyMesh::Point(1, 0, 0));
    // ... add other vertices

    // Add faces for a cube
    mesh.new_face(vhandle[0], vhandle[1], vhandle[2], vhandle[3]);
    // ... add other faces

    // Save the mesh
    OpenMesh::IO::write_mesh(mesh, "cube.obj");

    return 0;
}

```

--------------------------------

### ComponentsPlugin Initialization and Setup

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/ComponentsPlugin_8cc_source

Initializes the ComponentsPlugin, sets descriptions, and adds pick modes for component manipulation. It also creates a toolbar with actions for splitting components and getting the biggest component. This requires Qt and OpenFlipper libraries.

```cpp
#include "ComponentsPlugin.hh"

const char *SPLIT_COMPONENTS = "SplitComponents";
const char *BIGGEST_COMPONENT = "ComponentsPluginBiggestComponent";

ComponentsPlugin::ComponentsPlugin():
    splitAction_(NULL),
    biggestAction_(NULL){}

void ComponentsPlugin::initializePlugin() {
}

void ComponentsPlugin::pluginsInitialized() {
    if ( ! OpenFlipper::Options::gui())
        return;

    setDescriptions();

    emit addPickMode( SPLIT_COMPONENTS );
    emit addPickMode( BIGGEST_COMPONENT );

    QToolBar* toolbar = new QToolBar("Components Toolbar");
    splitAction_ = new QAction(tr("&Split into components"), this);
    splitAction_->setCheckable( true );
    splitAction_->setStatusTip(tr("Clicked objects are splitted into components"));
    splitAction_->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"components_split_components.png") );
    connect(splitAction_, SIGNAL(triggered()), this, SLOT(slotSplitComponentsButton()) );
    toolbar->addAction(splitAction_);

    biggestAction_ = new QAction(tr("&Get biggest component"), this);
}
```

--------------------------------

### OpenMesh SetUp and TearDown Methods

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/unittests__mesh__dual_8cc_source

Provides the SetUp and TearDown methods for a test fixture in C++. SetUp is called before each test, and TearDown is called after each test, allowing for initialization and cleanup of test resources.

```C++
virtual void SetUp() {
    // Do some initial stuff with the member data here...
}

virtual void TearDown() {
    // Do some final stuff with the member data here...
}
```

--------------------------------

### OpenMesh Base Class Setup and Teardown

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/unittests__smoother_8cc_source

Provides base setup and teardown functions for OpenMesh tests. SetUp() is called before each test, and TearDown() is called after all tests.

```cpp
class OpenMeshBase {
protected:
    virtual void SetUp() {
        // Do some initial stuff with the member data here...
    }
    virtual void TearDown() {
        // Do some final stuff with the member data here...
    }
    //Mesh mesh_;
};
```

--------------------------------

### Get Cell Vertices (HalfFaceHandle)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/TetrahedralMeshTopologyKernel_8cc_source

Retrieves the vertices of a cell's half-face, starting from the first half-edge. This function serves as a simplified interface for getting cell vertices when the starting half-edge is known or can be defaulted.

```cpp
std::vector<VertexHandle> TetrahedralMeshTopologyKernel::get_cell_vertices(HalfFaceHandle hfh) const
{
    return get_cell_vertices(hfh, halfface(hfh).halfedges().front());
}
```

--------------------------------

### Initialize and Setup Help Engine

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/helpWidget_8cc_source

Initializes a QHelpEngine with a specified filename and sets up its data. It then retrieves all registered documentations and lists available documentation files in the help directory. The code iterates through these files to register them with the help engine, handling cases where documentation might already be registered or needs to be re-registered if its location has changed. Errors during registration are reported to stderr.

```cpp
helpEngine_ = new QHelpEngine(filename, this);

helpEngine_->setupData();

// Get all currently registered nameSpaces
QStringList registeredNamespaces =helpEngine_->registeredDocumentations();

QStringList documentationFiles;

// Get a list of all loaded documentation files from the namespaces
QStringList helpFiles = helpDir.entryList(QStringList("*.qch"),QDir::Files);

// Write absolute path into filenames
for (QStringList::iterator iter = helpFiles.begin(); iter != helpFiles.end(); ++iter)
*iter = helpDir.path()+ OpenFlipper::Options::dirSeparator() + *iter;

for ( int i = 0; i < registeredNamespaces.size() ; ++i)
{
QString registredFilename (helpEngine_->documentationFileName(registeredNamespaces[i]));

// re-register documentation if location changed
if (helpFiles.indexOf(registredFilename) != -1)
documentationFiles.push_back( registredFilename );
else
helpEngine_->unregisterDocumentation(registeredNamespaces[i]);
}

for ( int i = 0 ; i < helpFiles.size() ; ++i ) {
const QString filename = helpFiles[i];

// Don't register files twice (stored between multiple OpenFlipper executions)
if (documentationFiles.contains(filename))
continue;

// Try to register the file
if ( !helpEngine_->registerDocumentation( filename ) ) {
std::cerr << "Error when trying to register file " << filename.toStdString() << std::endl;
std::cerr << helpFiles[i].toStdString() << " :" << helpEngine_->error().toStdString() << std::endl;
}

}
```

--------------------------------

### HelpWidget Constructor and SetHomeSite

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/classHelpWidget-members

This snippet shows the constructor for the HelpWidget class, which allows initialization with a parent widget, an optional home site, and a flag to load the home site. It also includes the setHomeSite method to update the home site after initialization.

```cpp
HelpWidget(QWidget *parent=0, const QString &_homeSite="", const bool _loadHomeSite=true) (defined in HelpWidget)| HelpWidget|
void setHomeSite(const QString &_homeSite) (defined in HelpWidget)| HelpWidget|
```

--------------------------------

### Get Arrow Start Position

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/ArrowNode_8cc_source

Retrieves the starting position of a specified arrow. This is a simple getter function that accesses the 'start' member of the arrow object.

```C++
Vec3f ArrowNode::arrowStart(int _arrowID) const
{
return arrows_[_arrowID].start;
}
```

--------------------------------

### HelpWidget Constructor and setHomeSite

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/classHelpWidget

The constructor initializes the HelpWidget with an optional parent widget, a home site URL, and a flag to load the home site. The setHomeSite function allows updating the home site URL after initialization.

```cpp
HelpWidget(QWidget *_parent=0, const QString &_homeSite="", const bool _loadHomeSite=true)
void setHomeSite(const QString &_homeSite)
```

--------------------------------

### Usage Information Display (C++)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/src_2OpenMesh_2Examples_2Tutorial09_2io__options_8cc_source

Prints the usage instructions for the command-line tool, detailing available options for reading and writing mesh data. This function is called when the program starts or encounters invalid arguments.

```C++
void usage_and_exit(int xcode)
{
 std::ostream &os = xcode ? std::cerr : std::cout;

 os << "Usage: io_options [Options] <input> <output>\n"
 << std::endl;
 os << " Read and write a mesh, using OpenMesh::IO::Options\n"
 << std::endl;
 os << "Options:\n"
 << std::endl;
 os << "a) read options\n"
 << std::endl
 << " -b\n"
 << "\tAssume input file is a binary file\n"
 << std::endl
 << " -s\n"
 << "\tSwap byte order when reading a binary file!\n"
 << std::endl;
 os << "b) write options\n"
 << std::endl
 << " -B\n"
 << "\tWrite binary data\n"
 << std::endl
 << " -S\n"
 << "\tSwap byte order, when writing binary data\n"
 << std::endl
 << " -M/-L\n"
 << "\tUse MSB/LSB byte ordering, when writing binary data\n"
 << std::endl
 << " -V{n|t|c}\n"
 << "\tWrite vertex normals, texcoords, and/or colors\n"
 << std::endl
 << " -F{n|c}\n"
 << "\tWrite face normals, and/or colors\n"
;
```

--------------------------------

### OpenMesh::SmartHalfedgeHandle::from - Get Starting Vertex

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/SmartHandles_8hh_source

Returns the vertex handle at the start of the halfedge. This is the vertex from which the halfedge originates.

```cpp
SmartVertexHandle from() const
```

--------------------------------

### First Steps - Building a cube with OpenMesh

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/tutorial_05

A tutorial demonstrating how to create a basic cube using the OpenMesh library. This example likely covers mesh creation, vertex and face definition, and basic mesh manipulation.

```c++
// Example for building a cube with OpenMesh (conceptual)
/*
#include <OpenMesh/Core/IO/MeshIO.hh>
#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh>

// Define a mesh type
// typedef OpenMesh::TriMesh_ArrayKernelT<OpenMesh::Props::Normal> MyMesh;

// MyMesh mesh;

// Add vertices for a cube
// MyMesh::VertexHandle vhandle[8];
// vhandle[0] = mesh.new_vertex(MyMesh::Point(-1.0, -1.0,  1.0));
// ... add other 7 vertices ...

// Add faces for a cube
// mesh.new_face(vhandle[0], vhandle[1], vhandle[2], vhandle[3]);
// ... add other 5 faces ...

// Save the mesh
// OpenMesh::IO::write_mesh(mesh, "cube.obj");
*/

```

--------------------------------

### Get Vertex Handle from HalfEdge Start in TopologyKernel

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/TopologyKernel_8hh_source

Retrieves the vertex handle from which a given half-edge originates. Useful for traversing edges from their starting points.

```cpp
VertexHandle from_vertex_handle(const HalfEdgeHandle &_h) const
```

--------------------------------

### Get Arrow Start Position in SceneGraph (C++)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/ArrowNode_8cc_source

Retrieves the starting position (Vec3f) of a specific arrow. This defines the origin point of the arrow.

```C++
Vec3f arrowStart(int _arrowID) const
Return the start position of an arrow.
```

--------------------------------

### Build Example Mesh

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/building_openvolumemesh

This command builds a specific example named 'simple_mesh' which is part of the OpenVolumeMesh project. This target must be built explicitly and its binary is usually found in 'Build/Examples'.

```bash
make simple_mesh

```

--------------------------------

### Get Start Offset in Face Buffer (C++)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/StripProcessorT_8hh_source

Returns the starting offset within the face buffer. This is used in conjunction with texture information to locate specific texture data.

```cpp
int startOffset
Start offset in the face buffer.
**Definition:** StripProcessorT.hh:117
```

--------------------------------

### Setup File and Script Menus

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/baseWidget_8cc_source

Creates and configures the main menu bar with 'File' and 'Script' menus. It adds actions for New, Open, Save, Save As, Close, and opening the script editor, each with associated icons and keyboard shortcuts. Dependencies include Qt GUI and core modules.

```cpp
132 QMenu *menu = new QMenu (tr("&File"));
133 QIcon icon;
134
135 icon.addFile(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"add-empty-object.png");
136 menu->addAction (icon, tr("New"), this, SLOT (newFile()), QKeySequence::New);
137
138 icon.addFile(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"document-open.png");
139 menu->addAction (icon, tr("Open ..."), this, SLOT (load()), QKeySequence::Open);
140
141 menu->addSeparator ();
142
143 icon.addFile(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"document-save.png");
144 menu->addAction (icon, tr("Save"), this, SLOT (save()), QKeySequence::Save);
145
146 icon.addFile(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"document-save-as.png");
147 menu->addAction (icon, tr("Save as ..."), this, SLOT (saveAs()), QKeySequence::SaveAs);
148 menu->addSeparator ();
149
150 icon.addFile(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"window-close.png");
151 menu->addAction (icon, tr("Close"), this, SLOT (close()), QKeySequence::Close);
152
153 menuBar()->addMenu (menu);
154
155 menu = new QMenu (tr("&Script"));
156 icon.addFile(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"scriptEditor.png");
157 menu->addAction (icon, tr("Open in script editor"), this, SLOT (codeToScript()));
158
159 menuBar()->addMenu (menu);
```

--------------------------------

### Create Help Menu and Action

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/MenuBar_8cc_source

Sets up the Help menu and adds an action to open the Help Browser. It configures the action's status tip, 'what's this' text, and sets an icon for the action.

```C++
helpMenu_ = new QMenu(tr("Help"));
menuBar()->addMenu(helpMenu_);
menus_[tr("Help")] = helpMenu_;

//Open Help Browser
QAction* AC_HelpBrowser = new QAction(tr("Help"), this);
AC_HelpBrowser->setStatusTip(tr("Open Help Browser with Documentation"));
AC_HelpBrowser->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"help-browser.png"));
AC_HelpBrowser->setWhatsThis(tr("Open the <b>Help Browser</b>"));
```

--------------------------------

### Get Begin Iterator for Half-Edge Properties in OpenVolumeMesh

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/classOpenVolumeMesh_1_1ResourceManager-members

Provides an iterator to the start of the half-edge properties in the ResourceManager, enabling iteration through these properties.

```cpp
halfedge_props_begin() const;

```

--------------------------------

### Initialize Plugins Step 2 Alternative - C++

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/BaseInterface_8hh_source

An alternative method for initializing plugins, taking a vector of QPair for plugin options. Defined in `BaseInterface.hh`.

```C++
virtual void pluginsInitialized(QVector< QPair< QString, QString >> const &_pluginOptions)
Initialize Plugin step 2 alternative.
**Definition:** BaseInterface.hh:101
```

--------------------------------

### Get Plugin Name

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/TypePolyhedralMesh_8cc_source

Returns the name of the plugin. This is typically used to identify the plugin, for example, in lists or logs.

```C++
QString name()
Return a name for the plugin.
**Definition:** TypeHexahedralMesh.hh:112
```

--------------------------------

### Get Mesh Boundary from Vertex (C++)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/MeshFunctionsT__impl_8hh_source

Retrieves the boundary of a mesh starting from a given vertex. It iterates along the boundary edges until the starting vertex is revisited. Handles potential partial loops by issuing a warning. Depends on mesh data structures and iteration capabilities.

```cpp
template < typename MeshT , typename VectorT >
bool get_boundary(MeshT& _mesh, 
typename MeshT::VertexHandle _vh, 
std::vector< std::pair< VectorT , typename MeshT::VertexHandle > >& _boundary)
{
_boundary.clear();
typename MeshT::VertexHandle last = _vh;
const typename MeshT::VertexHandle begin = _vh;

std::set< typename MeshT::VertexHandle > set;

//walk along boundary
do {
//insert current Vertex (which is on boundary to set (needed to detect loops)
set.insert( _vh );

// store the current vertex in the boundary list
_boundary.push_back(std::pair< VectorT , typename MeshT::VertexHandle > ( (VectorT)_mesh.point(_vh) , _vh ) );

// iterate over all outgoing halfedges of the current vertex to find next one
for (typename MeshT::VertexOHalfedgeIter vohe_it(_mesh,_vh); vohe_it.is_valid() ; ++vohe_it) {

//if vertex is on the boundary use it as the next one (if its not the one, we are comming from)
if ( _mesh.is_boundary(*vohe_it) && ( _mesh.to_vertex_handle(*vohe_it) != last ) ) {
last = _vh;
_vh = _mesh.to_vertex_handle(*vohe_it);
break;
}
}
// stop if we find a vertex which is already in the list (can also detect partial loops)
} while ( set.count( _vh ) == 0 );

if ( begin != _vh ) {
std::cout << "Warning in ( GeometryFunctions.cc get_boundary ) : boundary loop may be partial ( start- != endpoint ) " << std::endl;
}

return true;
}

```

--------------------------------

### OpenMeshProperties Test Setup

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/unittests__property_8cc_source

Sets up the OpenMeshProperties test class, inheriting from OpenMeshBase. The SetUp function is designed to be executed before each individual test.

```C++
#include <gtest/gtest.h>
#include <Unittests/unittests_common.hh>

namespace {

class OpenMeshProperties : public OpenMeshBase {

protected:

// This function is called before each test is run
virtual void SetUp() {


```

--------------------------------

### Get Begin Iterator for Mesh Properties in OpenVolumeMesh

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/classOpenVolumeMesh_1_1ResourceManager-members

Returns an iterator to the start of the mesh properties within the ResourceManager, allowing traversal of all mesh-level properties.

```cpp
mesh_props_begin() const;

```

--------------------------------

### Start Download

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/classOptionsWidget

Initiates the download of a specified file from a given URL.

```cpp
void OptionsWidget::startDownload (QString _url)
{
    // Implementation details here
}
```

--------------------------------

### OpenMesh: Building a Cube Tutorial

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/tutorial_build

A step-by-step tutorial demonstrating how to build a basic cube using OpenMesh. This example focuses on fundamental mesh construction techniques, including vertex and face creation.

```cpp
#include <iostream>
#include <OpenMesh/Core/IO/MeshIO.hh>
#include <OpenMesh/Core/Mesh/PolyMeshT.hh>

typedef OpenMesh::PolyMeshT<> Mesh;

int main(int argc, char** argv)
{
    Mesh mesh;

    // Add vertices for a cube
    Mesh::VertexHandle vhandle[8];
    vhandle[0] = mesh.new_vertex(Mesh::Point(-1.0, -1.0,  1.0));
    vhandle[1] = mesh.new_vertex(Mesh::Point( 1.0, -1.0,  1.0));
    vhandle[2] = mesh.new_vertex(Mesh::Point( 1.0,  1.0,  1.0));
    vhandle[3] = mesh.new_vertex(Mesh::Point(-1.0,  1.0,  1.0));
    vhandle[4] = mesh.new_vertex(Mesh::Point(-1.0, -1.0, -1.0));
    vhandle[5] = mesh.new_vertex(Mesh::Point( 1.0, -1.0, -1.0));
    vhandle[6] = mesh.new_vertex(Mesh::Point( 1.0,  1.0, -1.0));
    vhandle[7] = mesh.new_vertex(Mesh::Point(-1.0,  1.0, -1.0));

    // Add faces for the cube
    mesh.new_face(vhandle[0], vhandle[1], vhandle[2], vhandle[3]); // Front face
    mesh.new_face(vhandle[7], vhandle[6], vhandle[5], vhandle[4]); // Back face
    // ... add other faces ...

    // Example: Saving the mesh
    OpenMesh::IO::write_mesh(mesh, "cube.obj");

    return 0;
}

```

--------------------------------

### Get OpenGL Context Width

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/TranslationManipulatorNode_8cc_source

Retrieves the width of the current OpenGL context. This value is essential for viewport setup and rendering calculations.

```cpp
int context_width() const
get gl context width 
**Definition:** GLState.hh:827
```

--------------------------------

### OpenFlipper Application Initialization and KeyGenWidget Display (C++)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/keygen_8cc_source

This snippet demonstrates the basic setup for an OpenFlipper application. It initializes the Qt application, creates an instance of the KeyGenWidget, displays it, and starts the application's event loop. This is a common pattern for launching GUI applications in Qt.

```cpp
#include <QApplication>

#include <QtWidgets>

#include <QFile>
#include <QMessageBox>
#include <iostream>
#include <OpenFlipper/LicenseManager/keyGen/keygenWidget.hh>

int main(int argc, char **argv)
{
 QApplication a( argc, argv );

 KeyGenWidget* keyGenWidget = new KeyGenWidget(0);

 // Show the widget
 keyGenWidget->show();
 a.exec();


 return 0;

}
```

--------------------------------

### Get From-Vertex of Half-Edge in C++

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/TopologyKernel_8hh_source

Retrieves the starting vertex handle of a given half-edge. This provides the origin point of a directed edge segment.

```cpp
VertexHandle from_vertex_handle(const HalfEdgeHandle& _h) const {
  return halfedge(_h).from_vertex();
}
```

--------------------------------

### SimpleViewer: Initialization

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/classSimpleViewer

Private function responsible for the initial setup of the SimpleViewer, including OpenGL format and sharing contexts with other widgets.

```cpp
void initialize (const OFGLFormat &_format, OFGLWidget *_shareWidget=NULL, bool useDefaultSceneGraph=true)
```

--------------------------------

### Get Cell Vertices from Halfface

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/TetrahedralMeshTopologyKernel_8hh_source

Retrieves vertex handles associated with a cell, starting from a given halfface. This overload takes a CellHandle and a HalfFaceHandle.

```cpp
std::vector<VertexHandle> get_cell_vertices(HalfFaceHandle hfh) const;
```

--------------------------------

### First Steps - Building a cube with OpenMesh

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/tutorial_03

A tutorial demonstrating the fundamental steps to create a simple geometric shape, a cube, using the OpenMesh library. This example serves as an entry point for new users to understand mesh creation and manipulation.

```cpp
#include <iostream>
#include <OpenMesh/Core/IO/MeshReader.hh>
#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh>

typedef OpenMesh::TriMesh_ArrayKernelT<OpenMesh::Props::Normal> MyMesh;

int main(int argc, char** argv)
{
    MyMesh mesh;

    // Allocate vertices
    MyMesh::VertexHandle vhandle[8];
    vhandle[0] = mesh.new_vertex(MyMesh::Point(0, 0, 0));
    vhandle[1] = mesh.new_vertex(MyMesh::Point(1, 0, 0));
    vhandle[2] = mesh.new_vertex(MyMesh::Point(1, 1, 0));
    vhandle[3] = mesh.new_vertex(MyMesh::Point(0, 1, 0));
    vhandle[4] = mesh.new_vertex(MyMesh::Point(0, 0, 1));
    vhandle[5] = mesh.new_vertex(MyMesh::Point(1, 0, 1));
    vhandle[6] = mesh.new_vertex(MyMesh::Point(1, 1, 1));
    vhandle[7] = mesh.new_vertex(MyMesh::Point(0, 1, 1));

    // Allocate faces
    mesh.new_face(vhandle[0], vhandle[1], vhandle[2], vhandle[3]);
    mesh.new_face(vhandle[0], vhandle[4], vhandle[5], vhandle[1]);
    mesh.new_face(vhandle[1], vhandle[5], vhandle[6], vhandle[2]);
    mesh.new_face(vhandle[2], vhandle[6], vhandle[7], vhandle[3]);
    mesh.new_face(vhandle[3], vhandle[7], vhandle[4], vhandle[0]);
    mesh.new_face(vhandle[4], vhandle[7], vhandle[6], vhandle[5]);

    // Add normals
    mesh.update_normals();

    // Save the mesh
    OpenMesh::IO::write_mesh(mesh, "cube.off");

    return 0;
}

```

--------------------------------

### OpenMesh::SmartVertexHandle::out - Get Outgoing Halfedge

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/SmartHandles_8hh_source

Returns an outgoing halfedge handle for the vertex. This is one of the halfedges that starts at this vertex.

```cpp
SmartHalfedgeHandle out() const
```

--------------------------------

### Plugin Initialization and Support (FilePolyLinePlugin)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/classFilePolyLinePlugin-members

Contains methods for initializing the plugin, checking for its existence, and determining if a GUI is supported. It also includes a method to return the plugin's version.

```C++
void FilePolyLinePlugin::initializePlugin()
bool FilePolyLinePlugin::noguiSupported()
QString FilePolyLinePlugin::supportedType()
QString FilePolyLinePlugin::name()
```

--------------------------------

### OpenMesh PolyConnectivity: Get Begin Iterator for Halfedges

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/PolyConnectivity_8hh_source

Returns the beginning iterator for halfedges in the connectivity. Used to start iterating over all halfedges.

```C++
HalfedgeIter OpenMesh::PolyConnectivity::halfedges_sbegin()
{
  // Begin iterator for halfedges.
}
```

--------------------------------

### OpenMesh Tutorials: Building a Cube

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/tutorial_06

A tutorial demonstrating how to build a simple cube using the OpenMesh library. This example is likely for beginners to understand basic mesh creation and manipulation in C++.

```C++
// Example code for building a cube with OpenMesh
// This would involve creating vertices, faces, and associating them
// with the mesh object. Specific classes like Mesh, VertexHandle, FaceHandle
// would be used.
```

--------------------------------

### Mesh Setup and Teardown Methods

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/Type-OpenVolumeMesh_2libs_2OpenVolumeMesh_2src_2Unittests_2unittests__common_8hh_source

Defines the SetUp and TearDown virtual methods used in unit testing frameworks. SetUp is called before each test to initialize the mesh, disabling deferred and fast deletion. TearDown is called after tests to clean up resources.

```C++
virtual void SetUp() {

// Do some initial stuff with the member data here...
mesh_.enable_deferred_deletion(false);
mesh_.enable_fast_deletion(false);
}

// This function is called after all tests are through
virtual void TearDown() {

// Do some final stuff with the member data here...
}
```

--------------------------------

### OpenMesh PolyConnectivity: Get Begin Iterator for Faces

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/PolyConnectivity_8hh_source

Returns the beginning iterator for faces in the connectivity. Used to start iterating over all faces.

```C++
FaceIter OpenMesh::PolyConnectivity::faces_sbegin()
{
  // Begin iterator for faces.
}
```

--------------------------------

### OpenMesh: Building a Cube Tutorial

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/tutorial_09

A tutorial demonstrating how to build a simple cube using the OpenMesh library. This example covers the fundamental steps of creating vertices, defining faces, and assembling a basic geometric structure.

```cpp
#include <OpenMesh/Core/IO/MeshIO.hh>
#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh>

typedef OpenMesh::TriMesh_ArrayKernelT<OpenMesh::Props::Vertex::Normal, OpenMesh::Props::Face::Normal> MyMesh;

int main(int argc, char** argv)
{
    MyMesh mesh;

    // Add vertices for a cube
    MyMesh::VertexHandle vhandle[8];
    vhandle[0] = mesh.new_vertex(MyMesh::Point(-1, -1, -1));
    vhandle[1] = mesh.new_vertex(MyMesh::Point( 1, -1, -1));
    vhandle[2] = mesh.new_vertex(MyMesh::Point( 1,  1, -1));
    vhandle[3] = mesh.new_vertex(MyMesh::Point(-1,  1, -1));
    vhandle[4] = mesh.new_vertex(MyMesh::Point(-1, -1,  1));
    vhandle[5] = mesh.new_vertex(MyMesh::Point( 1, -1,  1));
    vhandle[6] = mesh.new_vertex(MyMesh::Point( 1,  1,  1));
    vhandle[7] = mesh.new_vertex(MyMesh::Point(-1,  1,  1));

    // Add faces for a cube
    mesh.new_face(vhandle[0], vhandle[1], vhandle[2], vhandle[3]);
    mesh.new_face(vhandle[4], vhandle[5], vhandle[6], vhandle[7]);
    mesh.new_face(vhandle[0], vhandle[4], vhandle[7], vhandle[3]);
    mesh.new_face(vhandle[1], vhandle[5], vhandle[6], vhandle[2]);
    mesh.new_face(vhandle[0], vhandle[1], vhandle[5], vhandle[4]);
    mesh.new_face(vhandle[3], vhandle[2], vhandle[6], vhandle[7]);

    // Add normals (example)
    mesh.update_normals();

    // Save the mesh (optional)
    // OpenMesh::IO::write_mesh(mesh, "cube.obj");

    return 0;
}
```

--------------------------------

### OpenMesh PolyConnectivity: Get Begin Iterator for Edges

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/PolyConnectivity_8hh_source

Returns the beginning iterator for edges in the connectivity. Used to start iterating over all edges.

```C++
EdgeIter OpenMesh::PolyConnectivity::edges_end() 
{
  // End iterator for edges.
}
```

--------------------------------

### QtLessAnnoyingDoubleSpinBox Class Documentation

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/classQtLessAnnoyingDoubleSpinBox

Detailed documentation for the QtLessAnnoyingDoubleSpinBox class, covering its constructors, validation, text conversion, and text stripping functionality.

```APIDOC
## QtLessAnnoyingDoubleSpinBox Class Documentation

### Description
This class provides a custom double spin box widget with enhanced usability.

### Class Members

#### Public Member Functions

- **QtLessAnnoyingDoubleSpinBox** (QWidget *_qwidget=Q_NULLPTR)
  - Constructor for the QtLessAnnoyingDoubleSpinBox.

- **validate** (QString &text, int &)
  - `virtual QValidator::State`
  - Validates the input text for the double spin box.

- **valueFromText** (const QString &text)
  - `virtual double`
  - Converts the input text to a double value.

#### Private Member Functions

- **strip_prefix_suffix** (const QString &text)
  - `QString`
  - Strips prefixes and suffixes from the input text.

### Detailed Description

Definition at line 59 of file QtLessAnnoyingDoubleSpinBox.hh.

* * *

The documentation for this class was generated from the following files:
  * OpenFlipper/libs_required/ACG/QtWidgets/QtLessAnnoyingDoubleSpinBox.hh
  * OpenFlipper/libs_required/ACG/QtWidgets/QtLessAnnoyingDoubleSpinBox.cc

### Inheritance Diagram

Inheritance diagram for QtLessAnnoyingDoubleSpinBox:

```
          +-------------------------+
          |         QWidget         |
          +-------------------------+
                     ^ 
                     |
          +-------------------------+
          | QtLessAnnoyingDoubleSpinBox |
          +-------------------------+
```

### Related Classes

- QtLessAnnoyingDoubleSpinBox
```

--------------------------------

### FileOMPlugin::supportedType - Get Supported Data Type

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/FileOM_8hh_source

Returns the data type that this plugin supports. For example, it might return DATA_TRIANGLE_MESH.

```cpp
DataType supportedType()
Return your supported object type( e.g. DATA_TRIANGLE_MESH ) 
**Definition:** FileOM.cc:103
```

--------------------------------

### OpenMesh Tutorials: Building a Cube

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/tutorial_01

A foundational tutorial demonstrating how to build a simple cube using the OpenMesh library. This example covers basic mesh creation, including adding vertices and faces, to illustrate the core concepts of mesh manipulation.

```cpp
#include <OpenMesh/Core/IO/MeshIO.hh>
#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh>

typedef OpenMesh::TriMesh_ArrayKernelT<OpenMesh::Props::Normal> MyMesh;

int main(int argc, char** argv)
{
    MyMesh mesh;

    // Add vertices for a cube
    MyMesh::VertexHandle vhandle[8];
    vhandle[0] = mesh.new_vertex(MyMesh::Point(-1.0, -1.0,  1.0));
    vhandle[1] = mesh.new_vertex(MyMesh::Point( 1.0, -1.0,  1.0));
    vhandle[2] = mesh.new_vertex(MyMesh::Point( 1.0,  1.0,  1.0));
    vhandle[3] = mesh.new_vertex(MyMesh::Point(-1.0,  1.0,  1.0));
    vhandle[4] = mesh.new_vertex(MyMesh::Point(-1.0, -1.0, -1.0));
    vhandle[5] = mesh.new_vertex(MyMesh::Point( 1.0, -1.0, -1.0));
    vhandle[6] = mesh.new_vertex(MyMesh::Point( 1.0,  1.0, -1.0));
    vhandle[7] = mesh.new_vertex(MyMesh::Point(-1.0,  1.0, -1.0));

    // Add faces (triangles) for the cube
    mesh.new_face(vhandle[0], vhandle[1], vhandle[2]);
    mesh.new_face(vhandle[0], vhandle[2], vhandle[3]);
    // ... add remaining faces ...

    // Compute normals
    mesh.update_normals();

    // Save the mesh (optional)
    // OpenMesh::IO::write_mesh(mesh, "cube.obj");

    return 0;
}

```

--------------------------------

### Get Supported Data Type (C++)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/classTypePolyMeshPlugin

Returns the data type that this plugin supports, for example, DATA_TRIANGLE_MESH. This is used by the core to determine plugin compatibility.

```cpp
DataType TypePolyMeshPlugin::supportedType  () 
inline virtual
Return your supported object type( e.g. DATA_TRIANGLE_MESH )
The function is used from addEmpty in the core to check if your plugin can create an object of a given dataType. If so, your addEmpty function will be invoked to create it.
Implements TypeInterface.
Definition at line 99 of file TypePolyMesh.hh.
```

--------------------------------

### Create and Configure 'Options' Action

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/MenuBar_8cc_source

This code sets up a 'Options' QAction for the application, defining its status tip and 'whats this' description. It assigns an icon and connects the 'triggered' signal to the 'showOptionsWidget' slot.

```c++
QAction* AC_Options = new QAction(tr("Options"), this);
AC_Options->setStatusTip(tr("Edit OpenFlipper Options"));
AC_Options->setWhatsThis(tr("Edit OpenFlipper Options"));
AC_Options->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"options.png"));
connect(AC_Options, SIGNAL(triggered()), this, SLOT(showOptionsWidget()));
fileMenu_->addAction(AC_Options);
```

--------------------------------

### Get Half-Edge Vertices (C++)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/TopologyKernel_8hh_source

Retrieves the two vertex handles associated with a given half-edge. It populates a vector with these handles, starting with the `from_vertex_handle` of the half-edge.

```cpp
std::vector<VertexHandle> halfedge_vertices(const HalfEdgeHandle& _h) const {
  std::vector<VertexHandle> res(2);
  res[0] = from_vertex_handle(_h);

```

--------------------------------

### BackupPlugin: Initialization and Updates

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/classBackupPlugin-members

Methods related to the initialization of the plugin, including setting up options widgets, processing plugin initialization signals, and updating internal states or views.

```C++
**initializeOptionsWidget**(QWidget *&_widget) (defined in BackupPlugin)| BackupPlugin| privateslot
```

```C++
**initializePlugin**() (defined in BackupPlugin)| BackupPlugin| privateslot
```

```C++
**pluginsInitialized**() (defined in BackupPlugin)| BackupPlugin| privateslot
```

```C++
**updateView**() (defined in BackupPlugin)| BackupPlugin| signal
```

```C++
**updateButtons**() (defined in BackupPlugin)| BackupPlugin| privateslot
```

--------------------------------

### Get Viewer Count

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/PluginFunctions_8hh

Returns the number of active viewers in the application. This is relevant for multi-view setups or managing different rendering windows.

```C++
int | PluginFunctions::viewers ()
```

--------------------------------

### QtLessAnnoyingDoubleSpinBox Source Files

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/classQtLessAnnoyingDoubleSpinBox

Lists the source files where the QtLessAnnoyingDoubleSpinBox class documentation is generated from.

```cpp
* OpenFlipper/libs_required/ACG/QtWidgets/QtLessAnnoyingDoubleSpinBox.hh
* OpenFlipper/libs_required/ACG/QtWidgets/QtLessAnnoyingDoubleSpinBox.cc
```

--------------------------------

### MemInfoPlugin: Initialize Plugin

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/MemInfo_8hh_source

Initializes the MemInfo plugin. This is the entry point for the plugin's setup process, likely involving setting up timers and UI elements.

```c++
void MemInfoPlugin::initializePlugin() {
  // BaseInterface.
}
```

--------------------------------

### Get Plane Node in C++

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/PlaneObject_8hh_source

Retrieves the scenegraph Node for the plane. This is used to interact with the scene graph, for example, for rendering or picking operations.

```cpp
PlaneNode* planeNode();
```

--------------------------------

### Get Save Filename Filter

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/classSingleObjectPropertyModel

Returns the file filter string used for saving files. This guides the user in selecting appropriate save file formats.

```C++
virtual QString | getSaveFilenameFilter (unsigned int propId)
```

--------------------------------

### OpenFlipper Startup Process Details

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/dataFlow

Details the sequence of processes invoked when starting OpenFlipper. It references specific internal functions and interfaces involved in initialization and settings loading.

```Documentation
Starting OpenFlipper invokes the following processes:

## References:
BaseInterface::initializePlugin(),  
BaseInterface::pluginsInitialized(),  
INIInterface::loadIniFileOptions()
```

--------------------------------

### OpenMesh Tutorials: Building a Cube (C++)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/tutorial_07b

A C++ code example demonstrating the first steps in building a simple cube mesh using the OpenMesh library. This tutorial covers basic mesh creation and manipulation.

```cpp
#include <OpenMesh/Core/IO/MeshIO.hh>
#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernel.hh>

typedef OpenMesh::TriMesh_ArrayKernelT<...> MyMesh;

int main(int argc, char **argv) {
    MyMesh mesh;
    // Add vertices and faces to create a cube
    // ...
    OpenMesh::IO::write_mesh(mesh, "cube.obj");
    return 0;
}
```

--------------------------------

### Get Save File Name (Qt)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/namespaceACG

Opens a Qt file dialog for saving a file. It supports custom captions, filters, prompts for overwriting, and starting directories.

```cpp
QString | **getSaveFileName** (QWidget *_parent, const QString &_caption, const QString &_filter, bool _askOW, const QString &_start)
```

--------------------------------

### OpenMesh::SmartFaceHandle::halfedge - Get Face Halfedge

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/SmartHandles_8hh_source

Returns one of the halfedges belonging to the face. This is useful for starting traversals around the face boundary.

```cpp
SmartHalfedgeHandle halfedge() const
```

--------------------------------

### Getting All Leaf Objects in C++

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/Popup_8cc_source

Retrieves a list of all leaf nodes (visible objects) in the scene graph subtree starting from the current object. Defined in BaseObject.cc.

```cpp
QList< BaseObject *> getLeafs()
{
// get all leafes of the tree below this object ( These will be all visible objects )
}
```

--------------------------------

### Initialize and Run Google Test - main.cc

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/main_8cc_source

This snippet demonstrates the standard C++ entry point for an application using the Google Test framework. It initializes the test environment using `::testing::InitGoogleTest` and then runs all discovered tests via `RUN_ALL_TESTS()`.

```cpp
#include "gtest/gtest.h"


int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
```

--------------------------------

### Get Lower Parameter Bound - C++

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/BSplineCurveT_8hh_source

Returns the lower bound of the parameter domain for the B-Spline curve. This is the starting parameter value for curve evaluation.

```cpp
Scalar lower() const

```

--------------------------------

### Building a Cube with OpenMesh

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/tutorial_02

A tutorial demonstrating the creation of a simple cube using the OpenMesh library. This code example provides a foundational understanding of mesh construction in OpenMesh.

```c++
#include <OpenMesh/Core/IO/MeshIO.hh>
#include <OpenMesh/Core/Mesh/TriMesh.hh>

// Define vertex and face types for TriMesh
typedef OpenMesh::TriMesh_ArrayKernelT<>
  MyMesh;

int main(int argc, char** argv)
{
  MyMesh mesh;

  // Add vertices for a cube
  MyMesh::VertexHandle vhandle[8];
  vhandle[0] = mesh.new_vertex(MyMesh::Point(0,0,0));
  vhandle[1] = mesh.new_vertex(MyMesh::Point(1,0,0));
  // ... add other 6 vertices ...

  // Add faces for a cube
  mesh.new_face(vhandle[0], vhandle[1], vhandle[2]);
  // ... add other 5 faces ...

  // Save the mesh
  OpenMesh::IO::write_mesh(mesh, "cube.obj");

  return 0;
}

```

--------------------------------

### Show Plugins Action (C++)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/MenuBar_8cc_source

Creates a QAction to display loaded plugins. It sets an icon and status tip, then connects the triggered signal to a signal that shows the plugins. Dependencies include QAction, QIcon, and connect.

```cpp
QAction* AC_Plugins = new QAction(tr("Plugins"), this);
AC_Plugins->setStatusTip(tr("Show loaded plugins"));
AC_Plugins->setWhatsThis(tr("Show loaded plugins"));
AC_Plugins->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"network-connect.png"));
connect(AC_Plugins, SIGNAL(triggered()), this, SIGNAL(showPlugins()));
toolsMenu_->addAction(AC_Plugins);
```

--------------------------------

### Get Open Mesh Name (Qt)

Source: https://www.graphics.rwth-aachen.de/media/openflipper_static/Documentation/latest/namespaceACG

Opens a Qt file dialog specifically for selecting mesh files. It allows setting a parent widget, caption, and starting directory.

```cpp
QString | **getOpenMeshName** (QWidget *_parent, const QString &_caption, const QString &_start)
```
Tokens:
Raw