Theia

http://theia-sfm.org/
Admin
Theia is an open-source C++ computer vision library designed to provide efficient and reliable...
Tokens:40,591
Snippets:349
Trust Score:4.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Theia with make install

Source: http://theia-sfm.org/building.html

Run this command after a successful build to install the library. It is executed from the build directory.

```bash
make install

```

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

### Detecting Keypoints with KeypointDetector

Source: http://theia-sfm.org/features.html

Example workflow for initializing a detector and extracting keypoints from an image. The input vector for keypoints must be empty before calling DetectKeypoints.

```cpp
// Assume var keypoint_detector was created with one of the constructors below.

FloatImage input_image(input_image_filename);
const bool initialization_success = keypoint_detector.Initialize();

// Container for the detected keypoints.
std::vector<Keypoint> detected_keypoint;
const bool detection_success =
    keypoint_detector.DetectKeypoints(input_image, &detected_keypoints);
```

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

### Feature Extraction Workflow

Source: http://theia-sfm.org/features.html

Example demonstrating the workflow of loading an image, detecting keypoints with SiftDetector, and extracting descriptors using SiftDescriptorExtractor.

```cpp
// Open image we want to extract features from.
FloatImage input_image(input_image_filename);

// Detect keypoints.
SiftDetector sift_keypoint_detector;
bool keypoint_detector_init = sift_keypoint_detector.Initialize();
const bool keypoint_init_success = sift_keypoint_detector.Initialize();
std::vector<Keypoint> sift_keypoints;
const bool detection_success =
    sift_keypoint_detector.DetectKeypoints(input_image, &sift_keypoints);

// Initialize descriptor extractor.
SiftDescriptorExtractor sift_extractor;
const bool descriptor_init_succes = sift_extractor.Initialize();

// E.g., compute a single descriptor
Eigen::VectorXf sift_descriptor;
bool sift_success =
  sift_extractor.ComputeDescriptor(input_image, keypoint[0], &sift_descriptor);

// E.g., compute many descriptors.
std::vector<Eigen::VectorXf> sift_descriptors;
const bool extraction_success =
  sift_extractor.ComputeDescriptors(image, &sift_keypoints, &sift_descriptors)
```

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

### Link Theia with CMake

Source: http://theia-sfm.org/index.html

Use these commands in your CMakeLists.txt to find and link the Theia library after running make install.

```cmake
find_package(Theia REQUIRED)
include_directories(${THEIA_INCLUDE_DIRS})
target_link_libraries(my_library ${THEIA_LIBRARIES})
```

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

### Add view pairs to ViewGraph

Source: http://theia-sfm.org/sfm.html

Creates a ViewGraph and adds edges for view pairs with strong visual coherence, based on the number of matched features. The example shows how to iterate over view pair matches and add edges only when the match count exceeds a threshold.

```cpp
std::vector<View> views;
// Match all views in the set.
std::vector<ViewIdPair, TwoViewInfo> view_pair_matches;

ViewGraph view_graph;
for (const auto& view_pair : view_pair_matches) {
  const ViewIdPair& view_id_pair = view_pair.first;
  const TwoViewInfo& two_view_info = view_pair.second;
  // Only add view pairs to the view graph if they have strong visual coherence.
  if (two_view_info.num_matched_features > min_num_matched_features) {
    view_graph.AddEdge(views[view_id_pair.first],
                       views[view_id_pair.second],
                       two_view_info);
  }
}

// Process and/or manipulate the view graph.
```

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

### Using Ransac with LineEstimator in C++

Source: http://theia-sfm.org/ransac.html

Shows how to use the Ransac class with a LineEstimator to fit a line to data containing inliers and outliers. It sets RansacParameters with error_thresh, creates a Ransac<LineEstimator> object, calls Initialize() (which must always be called), and then Estimate() to obtain the best line and a RansacSummary. The example logs the estimated line parameters m and b.

```cpp
int main (int argc, char** argv) {
  // Generate your input data using your desired method.
  // We put pseudo-code here for simplicity.
  std::vector<Point> input_data;

  // Add 700 inliers.
  for (int i = 0; i < 700; i++) {
    input_data.push_back(inlier_point);
  }
  // Add 300 outliers.
  for (int i = 0; i < 300; i++) {
    input_data.push_back(outlier_point);
  }

  // Specify RANSAC parameters.
  double error_threshold = 0.3;
  int min_num_inliers = 600;
  int max_iters = 1000;

  // Estimate the line with RANSAC.
  LineEstimator line_estimator;
  Line best_line;
  // Set the ransac parameters.
  RansacParameters params;
  params.error_thresh = 0.1;

  // Create Ransac object, specifying the number of points to sample to
  // generate a model estimation.
  Ransac<LineEstimator> ransac_estimator(params, line_estimator);
  // Initialize must always be called!
  ransac_estimator.Initialize();

  RansacSummary summary;
  ransac_estimator.Estimate(input_data, &best_line, &summary);
  LOG(INFO) << "Line m = " << best_line.m << "*x + " << best_line.b;

  return 0;
}
```

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

### Instantiate and use FeatureMatcher

Source: http://theia-sfm.org/features.html

Demonstrates how to configure matcher options, add images to the matcher, and perform matching with or without geometric verification.

```cpp
FeatureMatcherOptions matcher_options;
BruteForceFeatureMatcher matcher(matcher_options);
// Or to instantiate the cascade hashing matcher:
CascadeHashingFeatureMatcher matcher(matcher_options);

// Add image features to the matcher.
for (int i = 0; i < num_images_to_match; i++) {
  matcher.AddImage(image_name[i], keypoints[i], descriptors[i]);

 // Or, you could add the image with known intrinsics for use during
 // geometric verification.
  matcher.AddImage(image_name[i], keypoints[i], descriptors[i], intrinsics[i]);
}
std::vector<ImagePairMatch> matches;
matcher.MatchImages(&matches);

// Or, with geometric verification:
VerifyTwoViewMatchesOptions geometric_verification_options;
matcher.MatchImages(geometric_verification_options, &matches);
```

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

### Install Gerrit commit-msg hook manually

Source: http://theia-sfm.org/contributions.html

Installs the Gerrit commit-msg hook manually on Windows or when the automatic download fails. This hook adds Change-Id lines to commits.

```bash
curl -o .git/hooks/commit-msg http://www.theia-sfm.org/_static/commit-msg
chmod +x .git/hooks/commit-msg

```

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

### Build a 3D reconstruction using a flagfile

Source: http://theia-sfm.org/applications.html

Create a 3D reconstruction from images or matches by pointing the `build_reconstruction` application at a flagfile. Recommended to copy and adjust `build_reconstruction_flags.txt` for your dataset.

```bash
./bin/build_reconstruction --flagfile=/path/to/build_reconstruction_flags.txt

```

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

### Run any application with a flagfile

Source: http://theia-sfm.org/applications.html

Provide a single .txt file of all command line flags for any Theia application. The `--flagfile` flag loads the flags from the file.

```bash
./bin/build_reconstruction --flagfile=build_reconstruction_flags.txt

```

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

### SiftDetector Constructor

Source: http://theia-sfm.org/features.html

Constructor for the SIFT keypoint detector, which uses VLFeat as the underlying engine. Parameters define the number of octaves, scale levels, and the starting octave.

```cpp
SiftDetector::SiftDetector(int _num_octaves , int _num_scale_levels , int _first_octave)
```

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

### Line estimation example with RANSAC

Source: http://theia-sfm.org/ransac.html

Defines a Point data structure, a Line model, and a LineEstimator class that estimates a line from two points and calculates the error as the y distance. This is used to illustrate the RANSAC interface.

```cpp
// Our "data".
struct Point {
  double x; double y;
};

// Our "model".
struct Line {
  double m; double b;
};

// Estimator class.
class LineEstimator: public Estimator<Point, Line> {
  // Number of points needed to estimate a line.
  double SampleSize() { return 2; }

  // Estimate a line from two points.
  bool EstimateModel(const std::vector<Point>& data,
                     std::vector<Line>* models) const {
    Line model;
    model.m = (data[1].y - data[0].y)/(data[1].x - data[0].x);
    model.b = data[1].y - model.m*data[1].x;
    models->push_back(model);
    return true;
  }

  // Calculate the error as the y distance of the point to the line.
  double Error(const Point& point, const Line& line) const {
    return point.y - (line.m*point.x + line.b);
  }
};
```

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

### View reconstruction with view_reconstruction

Source: http://theia-sfm.org/applications.html

Runs the view_reconstruction binary to open a basic OpenGL point cloud viewer. The reconstruction file can be generated using the ReconstructionWriter. The viewer displays points in black and cameras according to their intrinsic parameters. Controls include mouse drag to move/rotate, scroll or z to zoom, f to resize cameras, p to resize points, c to toggle camera wireframes, and t/T to adjust the minimum number of views for displaying a 3D point.

```bash
./bin/view_reconstruction --reconstruction=/path/to/theia/reconstruction

```

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

### Compare reconstructions with compare_reconstructions

Source: http://theia-sfm.org/applications.html

Runs the compare_reconstructions binary to align a reconstruction to a reference (ground truth) reconstruction and output statistics such as rotation difference, position difference, and intrinsic parameter differences. The reference_reconstruction is treated as ground truth; the reconstruction_to_align is aligned via a similarity transformation using cameras with the same name.

```bash
./bin/compare_reconstructions --reference_reconstruction=ground_truth_reconstruction --reconstruction_to_align=your_reconstruction --logtostderr

```

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

### Reproject a 3D point using the Camera class

Source: http://theia-sfm.org/cameras.html

Demonstrates setting up a camera with rotation and position, then reprojecting a homogeneous 3D point to a pixel coordinate.

```cpp
// Open an image and obtain camera parameters.
FloatImage image("my_image.jpg");
const Eigen::Matrix3d rotation = value obtained elsewhere...
const Eigen::Vector3d position = value obtained elsewhere...

// Set up the camera.
Camera camera;
camera.SetOrientationFromRotationMatrix(rotation);
camera.SetPosition(position);

// Obtain a homogeneous 3D point
const Eigen::Vector4d homogeneous_point3d = value obtained elsewhere...

// Reproject the 3D point to a pixel.
Eigen::Vector2d reprojection_pixel;
const double depth = camera.ProjectPoint(homogeneous_point3d, &pixel);
if (depth < 0) {
  LOG(INFO) << "Point was behind the camera!";
}

LOG(INFO) << "Homogeneous 3D point: " << homogeneous_point3d
          << " reprojected to the pixel value of " << reprojection_pixel;
```

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

### Build Theia with CMake and make

Source: http://theia-sfm.org/building.html

Run these commands from the Theia source directory to configure, build, and test the library. The build directory is created as 'theia-build'.

```bash
mkdir theia-build
cd theia-build
cmake ..
make -j4
make test

```

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

### Create Calibration File From EXIF

Source: http://theia-sfm.org/applications.html

Generates a calibration file by extracting EXIF information from a set of images.

```bash
./bin/create_calibration_file_from_exif --images=/path/to/images/*.jpg --output_calibration_file=/path/to/output/calibration.txt
```

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

### Read, Convert, and Write FloatImage

Source: http://theia-sfm.org/image.html

Demonstrates loading an image from a file, converting it to grayscale, and writing both the original and converted images to disk.

```cpp
FloatImage my_rgb_image(img_filename);

// Convert to grayscale.
FloatImage my_grayscale_image = my_rgb_image.AsGrayscaleImage();

// ... do some stuff ... //

// Write the image back out.
my_rgb_image.Write(out_filename);
my_grayscale_image.Write(out_filename);
```

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

### InitializeFromProjectionMatrix

Source: http://theia-sfm.org/cameras.html

Initializes the camera intrinsic and extrinsic parameters from a given projection matrix by decomposing it with a RQ decomposition.

```APIDOC
## InitializeFromProjectionMatrix

### Description
Initializes the camera intrinsic and extrinsic parameters from the projection matrix by decomposing the matrix with a RQ decomposition.

### Method
bool

### Parameters
#### Parameters
- **image_width** (int) - Required - The width of the image.
- **image_height** (int) - Required - The height of the image.
- **projection_matrix** (Matrix3x4d) - Required - The projection matrix to decompose.

### Notes
The projection matrix does not contain information about radial distortion, so those parameters will need to be set separately.

```

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

### Compute reconstruction statistics with compute_reconstruction_statistics

Source: http://theia-sfm.org/applications.html

Runs the compute_reconstruction_statistics binary to output basic information about a reconstruction, including reprojection error, number of cameras, number of 3D points, and average observations per 3D point.

```bash
./bin/compute_reconstruction_statistics --reconstruction=my_reconstruction --logtostderr

```

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

### KeypointDetector::Initialize

Source: http://theia-sfm.org/features.html

Initializes any internal parameters that must be generated, precalculated, or otherwise are independent of the image. Must be called before using the keypoint detector.

```APIDOC
## KeypointDetector::Initialize

### Description
Initializes any internal parameters that must be generated, precalculated, or otherwise are independent of the image. Must be called before using the keypoint detector.

### Method
Initialize

### Parameters
None.

### Response
#### Success Response
- **bool** - True if initialization succeeded, false otherwise.

```

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

### Solve L1 minimization with L1Solver

Source: http://theia-sfm.org/math.html

Demonstrates using L1Solver to minimize ||Ax - b|| under the L1 norm. Requires an initial guess for x and works with both sparse and dense matrices.

```cpp
Eigen::MatrixXd A;
Eigen::VectorXd b, x;
// Fill A and b with known values.

L1Solver::Options option;
L1Solver<Eigen::MatrixXd> l1_solver(options, A);
l1_solver.Solve(b, &x);
// x now contains the solution that minimizes ||Ax - b|| under L1 norm.
```

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

### Clone Theia repository from GerritHub

Source: http://theia-sfm.org/contributions.html

Clones the Theia repository from GerritHub. This is the first step after setting up git and a GitHub account.

```bash
git clone https://review.gerrithub.io/sweeneychris/TheiaSfM

```
Tokens:
Raw