text stringlengths 1 24.5M |
|---|
/***********************************************************************
* Software License Agreement (BSD License)
*
* Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
* Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
* Copyright 2011-2021 Jose Luis Blanco (jos... |
/*
The MIT License (MIT)
Copyright (c) 2012-2018 Syoyo Fujita and many contributors.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
t... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include "evaluator.h"
int main() {
// Change accordingly
std::string dataset_path{"/your/path/to/rbot/dataset/"};
std::string result_path{"/your/path/to/store/results/"};
std::vector<std::string> body_names{
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include "evaluator.h"
int main() {
// Change accordingly
std::string dataset_path{"/your/path/to/rbot/dataset/"};
std::string result_path{"/your/path/to/store/results/"};
std::vector<std::string> body_names{
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include "evaluator.h"
bool Evaluator::Init(const std::filesystem::path &dataset_path,
const std::vector<std::string> &body_names,
const std::string &sequence_name, bool use_oc... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECTTRACKING_EXAMPLES_EVALUATOR_H_
#define OBJECTTRACKING_EXAMPLES_EVALUATOR_H_
#include <rbgt/body.h>
#include <rbgt/common.h>
#include <rbgt/dataset_rbot_camera.h>
#include <rbgt/normal_image_viewer.h>
#inc... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/azure_kinect_camera.h>
#include <rbgt/image_viewer.h>
#include <rbgt/tracker.h>
#include <memory>
#include <string>
int main() {
// Change accordingly
const std::string save_path{"/your/path/to/save... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/body.h>
#include <rbgt/common.h>
#include <rbgt/azure_kinect_camera.h>
#include <rbgt/normal_image_viewer.h>
#include <rbgt/occlusion_mask_renderer.h>
#include <rbgt/region_modality.h>
#include <rbgt/rend... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/body.h>
#include <rbgt/common.h>
#include <rbgt/image_loader_camera.h>
#include <rbgt/normal_image_viewer.h>
#include <rbgt/occlusion_mask_renderer.h>
#include <rbgt/region_modality.h>
#include <rbgt/rend... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_AZURE_KINECT_CAMERA_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_AZURE_KINECT_CAMERA_H_
#include <rbgt/camera.h>
#include <rbgt/common.h>
#include <chrono>
#include <filesystem>
#includ... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_BODY_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_BODY_H_
#include <rbgt/common.h>
#include <Eigen/Dense>
#include <Eigen/Geometry>
#include <filesystem>
#include <iostream>
#include <s... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_CAMERA_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_CAMERA_H_
#include <rbgt/common.h>
#include <Eigen/Geometry>
#include <filesystem>
#include <fstream>
#include <opencv2/opencv.hpp>
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_COMMON_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_COMMON_H_
#include <Eigen/Dense>
#include <Eigen/Geometry>
#include <filesystem>
#include <fstream>
#include <opencv2/opencv.hpp>
#inc... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECTTRACKING_INCLUDE_RBGT_DATASET_RBOT_CAMERA_H_
#define OBJECTTRACKING_INCLUDE_RBGT_DATASET_RBOT_CAMERA_H_
#include <rbgt/camera.h>
#include <rbgt/common.h>
#include <filesystem>
#include <fstream>
#include... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_IMAGE_LOADER_CAMERA_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_IMAGE_LOADER_CAMERA_H_
#include <rbgt/camera.h>
#include <rbgt/common.h>
#include <filesystem>
#include <fstream>
#inclu... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_IMAGE_VIEWER_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_IMAGE_VIEWER_H_
#include <rbgt/camera.h>
#include <rbgt/common.h>
#include <rbgt/viewer.h>
#include <memory>
#include <opencv2/... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_MODEL_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_MODEL_H_
#include <rbgt/body.h>
#include <rbgt/common.h>
#include <rbgt/normal_image_renderer.h>
#include <rbgt/renderer_geometry.h>
#i... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_NORMAL_IMAGE_RENDERER_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_NORMAL_IMAGE_RENDERER_H_
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <rbgt/body.h>
#include <rbgt/camera.h>
#... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_NORMAL_IMAGE_VIEWER_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_NORMAL_IMAGE_VIEWER_H_
#include <rbgt/camera.h>
#include <rbgt/common.h>
#include <rbgt/normal_image_renderer.h>
#include... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_OCCLUSION_MASK_RENDERER_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_OCCLUSION_MASK_RENDERER_H_
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <rbgt/body.h>
#include <rbgt/camera.... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_REGION_MODALITY_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_REGION_MODALITY_H_
#include <rbgt/body.h>
#include <rbgt/camera.h>
#include <rbgt/common.h>
#include <rbgt/model.h>
#include ... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_RENDERER_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_RENDERER_H_
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <rbgt/camera.h>
#include <rbgt/common.h>
#include <rbgt/renderer_g... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_RENDERER_GEOMETRY_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_RENDERER_GEOMETRY_H_
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <rbgt/body.h>
#include <rbgt/common.h>
#include... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_TRACKER_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_TRACKER_H_
#include <rbgt/body.h>
#include <rbgt/camera.h>
#include <rbgt/common.h>
#include <rbgt/occlusion_mask_renderer.h>
#includ... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_RBGT_VIEWER_H_
#define OBJECT_TRACKING_INCLUDE_RBGT_VIEWER_H_
#include <rbgt/camera.h>
#include <rbgt/common.h>
#include <filesystem>
#include <memory>
#include <string>
namespace rbgt... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/azure_kinect_camera.h>
namespace rbgt {
AzureKinectCamera::~AzureKinectCamera() {
if (initialized_) {
device_.stop_cameras();
device_.close();
}
}
bool AzureKinectCamera::Init(const std::st... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/body.h>
namespace rbgt {
Body::Body(std::string name, std::filesystem::path geometry_path,
float geometry_unit_in_meter, bool geometry_counterclockwise,
bool geometry_enable_cullin... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/camera.h>
namespace rbgt {
void Camera::set_camera2world_pose(const Transform3fA &camera2world_pose) {
camera2world_pose_ = camera2world_pose;
world2camera_pose_ = camera2world_pose_.inverse();
}
v... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/common.h>
namespace rbgt {
void ReadValueFromFile(std::ifstream &ifs, bool *value) {
std::string parsed;
std::getline(ifs, parsed);
std::getline(ifs, parsed, '\t');
*value = stoi(parsed);
std:... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/dataset_rbot_camera.h>
namespace rbgt {
bool DatasetRBOTCamera::Init(const std::string &name,
const std::filesystem::path &dataset_path,
const s... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/image_loader_camera.h>
namespace rbgt {
bool ImageLoaderCamera::Init(const std::string &name,
const std::filesystem::path &load_path,
const std:... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/image_viewer.h>
namespace rbgt {
void ImageViewer::Init(const std::string &name,
std::shared_ptr<Camera> camera_ptr) {
name_ = name;
camera_ptr_ = std::move(camera_ptr);
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/model.h>
namespace rbgt {
Model::Model(std::string name) : name_{std::move(name)} {}
void Model::set_name(const std::string &name) { name_ = name; }
void Model::set_image_size(int image_size) { image_... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/normal_image_renderer.h>
namespace rbgt {
NormalImageRenderer::NormalImageRenderer() {
vertex_shader_code_ =
"#version 330 core\n"
"layout(location = 0) in vec3 aPos;\n"
"layout(loca... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/normal_image_viewer.h>
namespace rbgt {
bool NormalImageViewer::Init(
const std::string &name,
std::shared_ptr<RendererGeometry> renderer_geometry_ptr,
std::shared_ptr<Camera> camera_ptr) {
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/occlusion_mask_renderer.h>
namespace rbgt {
OcclusionMaskRenderer::OcclusionMaskRenderer() {
vertex_shader_code_body_id_ =
"#version 330 core\n"
"layout(location = 0) in vec3 aPos;\n"
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/region_modality.h>
namespace rbgt {
RegionModality::RegionModality() {
tikhonov_matrix_.setZero();
tikhonov_matrix_.diagonal().head<3>().array() = tikhonov_parameter_rotation_;
tikhonov_matrix_.di... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/renderer.h>
namespace rbgt {
bool Renderer::InitFromCamera(
const std::string &name,
std::shared_ptr<RendererGeometry> renderer_geometry_ptr,
const Camera &camera, float z_min, float z_max) ... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/renderer_geometry.h>
#define TINYOBJLOADER_IMPLEMENTATION
#include <tiny_obj_loader/tiny_obj_loader.h>
namespace rbgt {
int RendererGeometry::n_instances_ = 0;
RendererGeometry::RendererGeometry() { n... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/tracker.h>
namespace rbgt {
void Tracker::AddRegionModality(
std::shared_ptr<RegionModality> region_modality_ptr) {
region_modality_ptrs_.push_back(std::move(region_modality_ptr));
}
void Tracker... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2020 Manuel Stoiber, German Aerospace Center (DLR)
#include <rbgt/viewer.h>
namespace rbgt {
void Viewer::set_display_images(bool dispaly_images) {
display_images_ = dispaly_images;
}
void Viewer::StartSavingImages(const std::filesystem::path &path) {
save_images... |
/*
The MIT License (MIT)
Copyright (c) 2012-2018 Syoyo Fujita and many contributors.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
t... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include "opt_evaluator.h"
int main() {
// Directories
std::string dataset_directory{"/your/path/to/the/opt/dataset/"};
// Dataset configuration
std::vector<std::string> body_names{"soda", "chest", "ironman",... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include "rbot_evaluator.h"
int main() {
// Directories
std::string dataset_directory{"/your/path/to/the/rbot/dataset/"};
std::string result_directory{"/your/path/to/store/results/"};
// Dataset configuration
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include "opt_evaluator.h"
#include <tiny_obj_loader/tiny_obj_loader.h>
OPTEvaluator::OPTEvaluator(const std::string &name,
const std::filesystem::path &dataset_directory,
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECTTRACKING_EXAMPLES_OPT_EVALUATOR_H_
#define OBJECTTRACKING_EXAMPLES_OPT_EVALUATOR_H_
#include <srt3d/body.h>
#include <srt3d/common.h>
#include <srt3d/loader_camera.h>
#include <srt3d/normal_viewer.h>
#inc... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include "opt_evaluator.h"
int main() {
// Directories
std::string dataset_directory{"/your/path/to/the/opt/dataset/"};
// Dataset configuration
std::vector<std::string> body_names{"soda", "chest", "ironman",... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include "rbot_evaluator.h"
int main() {
// Directories
std::string dataset_directory{"/your/path/to/the/rbot/dataset/"};
// Dataset configuration
std::vector<std::string> body_names{
"ape", "bakingsoda... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include "rbot_evaluator.h"
RBOTEvaluator::RBOTEvaluator(const std::string &name,
const std::filesystem::path &dataset_directory,
const std::vector<std::string>... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECTTRACKING_EXAMPLES_RBOT_EVALUATOR_H_
#define OBJECTTRACKING_EXAMPLES_RBOT_EVALUATOR_H_
#include <srt3d/body.h>
#include <srt3d/common.h>
#include <srt3d/loader_camera.h>
#include <srt3d/normal_viewer.h>
#i... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/azure_kinect_camera.h>
#include <srt3d/image_viewer.h>
#include <srt3d/tracker.h>
#include <filesystem>
#include <memory>
#include <string>
int main() {
// Change accordingly
const std::filesystem:... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/azure_kinect_camera.h>
#include <srt3d/body.h>
#include <srt3d/common.h>
#include <srt3d/normal_viewer.h>
#include <srt3d/occlusion_renderer.h>
#include <srt3d/region_modality.h>
#include <srt3d/renderer... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/body.h>
#include <srt3d/common.h>
#include <srt3d/loader_camera.h>
#include <srt3d/normal_viewer.h>
#include <srt3d/occlusion_renderer.h>
#include <srt3d/region_modality.h>
#include <srt3d/renderer_geome... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_AZURE_KINECT_CAMERA_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_AZURE_KINECT_CAMERA_H_
#include <srt3d/camera.h>
#include <srt3d/common.h>
#include <chrono>
#include <filesystem>
#in... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_BODY_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_BODY_H_
#include <srt3d/common.h>
#include <Eigen/Dense>
#include <Eigen/Geometry>
#include <filesystem>
#include <iostream>
#include... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_CAMERA_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_CAMERA_H_
#include <srt3d/common.h>
#include <Eigen/Geometry>
#include <filesystem>
#include <fstream>
#include <opencv2/opencv.hpp... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_COMMON_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_COMMON_H_
#include <Eigen/Dense>
#include <Eigen/Geometry>
#include <filesystem>
#include <fstream>
#include <opencv2/opencv.hpp>
#i... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_IMAGE_VIEWER_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_IMAGE_VIEWER_H_
#include <srt3d/camera.h>
#include <srt3d/common.h>
#include <srt3d/viewer.h>
#include <memory>
#include <ope... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_LOADER_CAMERA_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_LOADER_CAMERA_H_
#include <srt3d/camera.h>
#include <srt3d/common.h>
#include <filesystem>
#include <fstream>
#include <iost... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_MODEL_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_MODEL_H_
#include <omp.h>
#include <srt3d/body.h>
#include <srt3d/common.h>
#include <srt3d/normal_renderer.h>
#include <srt3d/render... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_NORMAL_RENDERER_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_NORMAL_RENDERER_H_
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <srt3d/body.h>
#include <srt3d/camera.h>
#include ... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_NORMAL_VIEWER_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_NORMAL_VIEWER_H_
#include <srt3d/camera.h>
#include <srt3d/common.h>
#include <srt3d/normal_renderer.h>
#include <srt3d/rende... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_OCCLUSION_RENDERER_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_OCCLUSION_RENDERER_H_
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <srt3d/body.h>
#include <srt3d/camera.h>
#in... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_REGION_MODALITY_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_REGION_MODALITY_H_
#include <srt3d/body.h>
#include <srt3d/camera.h>
#include <srt3d/common.h>
#include <srt3d/model.h>
#in... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_RENDERER_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_RENDERER_H_
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <srt3d/camera.h>
#include <srt3d/common.h>
#include <srt3d/rende... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_RENDERER_GEOMETRY_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_RENDERER_GEOMETRY_H_
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <srt3d/body.h>
#include <srt3d/common.h>
#inc... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_TRACKER_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_TRACKER_H_
#include <srt3d/body.h>
#include <srt3d/camera.h>
#include <srt3d/common.h>
#include <srt3d/occlusion_renderer.h>
#inclu... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef OBJECT_TRACKING_INCLUDE_SRT3D_VIEWER_H_
#define OBJECT_TRACKING_INCLUDE_SRT3D_VIEWER_H_
#include <srt3d/camera.h>
#include <srt3d/common.h>
#include <srt3d/renderer_geometry.h>
#include <filesystem>
#include <... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/azure_kinect_camera.h>
namespace srt3d {
AzureKinectCamera::AzureKinectCamera(const std::string &name, float image_scale)
: Camera{name}, image_scale_{image_scale} {}
AzureKinectCamera::~AzureKine... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/body.h>
namespace srt3d {
Body::Body(const std::string &name, const std::filesystem::path &geometry_path,
float geometry_unit_in_meter, bool geometry_counterclockwise,
bool geomet... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/camera.h>
namespace srt3d {
Camera::Camera(const std::string &name) : name_{name} {}
void Camera::set_name(const std::string &name) { name_ = name; }
void Camera::set_camera2world_pose(const Transfor... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/common.h>
namespace srt3d {
void ReadValueFromFile(std::ifstream &ifs, bool *value) {
std::string parsed;
std::getline(ifs, parsed);
std::getline(ifs, parsed, '\t');
*value = stoi(parsed);
st... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/image_viewer.h>
namespace srt3d {
ImageViewer::ImageViewer(const std::string &name,
std::shared_ptr<Camera> camera_ptr)
: Viewer{name, std::move(camera_ptr)} {}
bool Image... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/loader_camera.h>
namespace srt3d {
LoaderCamera::LoaderCamera(const std::string &name,
const std::filesystem::path &load_directory,
const Intrinsic... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/model.h>
namespace srt3d {
Model::Model(const std::string &name, std::shared_ptr<Body> body_ptr,
const std::filesystem::path &directory,
const std::string &filename, float sph... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/normal_renderer.h>
namespace srt3d {
std::string NormalRenderer::vertex_shader_code_ =
"#version 330 core\n"
"layout(location = 0) in vec3 aPos;\n"
"layout(location = 1) in vec3 aNormal;\n"... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/normal_viewer.h>
namespace srt3d {
NormalViewer::NormalViewer(
const std::string &name, std::shared_ptr<Camera> camera_ptr,
std::shared_ptr<RendererGeometry> renderer_geometry_ptr, float opacit... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/occlusion_renderer.h>
namespace srt3d {
std::string OcclusionRenderer::vertex_shader_code_body_id_ =
"#version 330 core\n"
"layout(location = 0) in vec3 aPos;\n"
"uniform mat4 Trans;\n"
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/region_modality.h>
namespace srt3d {
RegionModality::RegionModality(const std::string &name,
std::shared_ptr<Body> body_ptr,
std::shared_pt... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/renderer.h>
namespace srt3d {
Renderer::Renderer(const std::string &name,
std::shared_ptr<RendererGeometry> renderer_geometry_ptr,
const Transform3fA &world2camera... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/renderer_geometry.h>
#define TINYOBJLOADER_IMPLEMENTATION
#include <tiny_obj_loader/tiny_obj_loader.h>
namespace srt3d {
int RendererGeometry::n_instances_ = 0;
RendererGeometry::RendererGeometry(con... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/tracker.h>
namespace srt3d {
Tracker::Tracker(const std::string &name) : name_{name} {}
void Tracker::AddRegionModality(
std::shared_ptr<RegionModality> region_modality_ptr) {
region_modality_pt... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2021 Manuel Stoiber, German Aerospace Center (DLR)
#include <srt3d/viewer.h>
namespace srt3d {
Viewer::Viewer(const std::string &name, std::shared_ptr<Camera> camera_ptr)
: name_{name}, camera_ptr_{std::move(camera_ptr)} {}
void Viewer::set_name(const std::string... |
/*
The MIT License (MIT)
Copyright (c) 2012-2018 Syoyo Fujita and many contributors.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
t... |
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <unistd.h>
#include <chrono>
#include <iomanip>
#include <ctime>
#include "hf3fs_usrbio.h"
#include <atomic>
#include <errno.h>
#include <vector>
#include <sys/stat.h>
extern "C" {
#include "fio.h"
#include "optgroup.h"
}
struct hf3f... |
#include "StorageBench.h"
#include <folly/init/Init.h>
#include "common/monitor/Monitor.h"
#include "memory/common/OverrideCppNewDelete.h"
DEFINE_bool(benchmarkNetwork, false, "Run in network benchmark mode");
DEFINE_bool(benchmarkStorage, false, "Run in storage benchmark mode");
DEFINE_bool(ignoreIOError, false, "I... |
#pragma once
#include <boost/algorithm/string.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/filesystem/string_file.hpp>
#include <common/utils/UtcTime.h>
#include <folly/experimental/coro/Collect.h>
#include <folly/futures/Barrier.h>
#include <folly/stats/TDigest.h>
#include <numeric>
#include <optional... |
#pragma once
#include "common/serde/Serde.h"
#include "common/utils/StrongType.h"
namespace hf3fs::serde {
template <typename T>
using SerdeToReadableMemberMethodReturnType = std::invoke_result_t<decltype(&T::serdeToReadable), T>;
template <typename T>
using SerdeToMemberMethodReturnType = std::invoke_result_t<decl... |
#pragma once
#include <arrow/io/file.h>
#include <optional>
#include <parquet/stream_reader.h>
#include <type_traits>
#include <utility>
#include <variant>
#include "SerdeObjectVisitor.h"
#include "SerdeSchemaBuilder.h"
#include "common/serde/Serde.h"
#include "common/utils/Nameof.hpp"
#include "common/utils/StrongTyp... |
#pragma once
#include <string_view>
#include <type_traits>
#include <utility>
#include <variant>
#include "Common.h"
#include "common/serde/Serde.h"
#include "common/utils/Nameof.hpp"
#include "common/utils/StrongType.h"
#include "common/utils/TypeTraits.h"
namespace hf3fs::analytics {
class ObjectVisitor {
public... |
#pragma once
#include <arrow/io/file.h>
#include <parquet/stream_writer.h>
#include <type_traits>
#include <utility>
#include <variant>
#include "SerdeObjectVisitor.h"
#include "SerdeSchemaBuilder.h"
#include "common/serde/Serde.h"
#include "common/utils/Nameof.hpp"
#include "common/utils/StrongType.h"
#include "commo... |
#pragma once
#include <folly/logging/xlog.h>
#include <numeric>
#include <parquet/exception.h>
#include <parquet/schema.h>
#include "SerdeStructVisitor.h"
#include "common/serde/Serde.h"
#include "common/utils/Result.h"
#include "common/utils/TypeTraits.h"
namespace hf3fs::analytics {
template <serde::SerdeType Ser... |
#pragma once
#include <folly/logging/xlog.h>
#include <string_view>
#include <type_traits>
#include <utility>
#include <variant>
#include "Common.h"
#include "common/serde/Serde.h"
#include "common/utils/Nameof.hpp"
#include "common/utils/StrongType.h"
#include "common/utils/TypeTraits.h"
namespace hf3fs::analytics ... |
#pragma once
#include <folly/Random.h>
#include <folly/concurrency/UnboundedQueue.h>
#include <future>
#include "SerdeObjectWriter.h"
#include "common/monitor/Recorder.h"
#include "common/monitor/ScopedMetricsWriter.h"
#include "common/utils/ConfigBase.h"
#include "common/utils/Path.h"
#include "common/utils/SysResou... |
#include <boost/algorithm/string.hpp>
#include <exception>
#include <folly/experimental/coro/BlockingWait.h>
#include <folly/init/Init.h>
#include <folly/logging/xlog.h>
#include <iostream>
#include "client/cli/admin/AdminEnv.h"
#include "client/cli/admin/registerAdminCommands.h"
#include "client/cli/common/Utils.h"
#... |
#pragma once
#include "client/cli/common/IEnv.h"
#include "client/core/CoreClient.h"
#include "client/meta/MetaClient.h"
#include "client/mgmtd/IMgmtdClientForAdmin.h"
#include "client/storage/StorageClient.h"
#include "common/kv/IKVEngine.h"
#include "fbs/core/user/User.h"
namespace hf3fs::client::cli {
struct Admin... |
#include "AdminUserCtrl.h"
#include <fmt/chrono.h>
#include <string>
#include "AdminEnv.h"
#include "client/cli/common/Dispatcher.h"
#include "client/cli/common/Utils.h"
#include "common/kv/WithTransaction.h"
#include "common/utils/ArgParse.h"
#include "common/utils/OptionalUtils.h"
#include "common/utils/Result.h"
#... |
#pragma once
#include "common/utils/Coroutine.h"
namespace hf3fs::client::cli {
class Dispatcher;
CoTryTask<void> registerAdminUserCtrlHandler(Dispatcher &dispatcher);
} // namespace hf3fs::client::cli
|
#include "client/cli/admin/Bench.h"
#include <boost/iostreams/device/array.hpp>
#include <boost/iostreams/stream.hpp>
#include <folly/Random.h>
#include <folly/executors/CPUThreadPoolExecutor.h>
#include <folly/executors/GlobalExecutor.h>
#include <folly/experimental/coro/BlockingWait.h>
#include <folly/experimental/c... |
#pragma once
#include "common/utils/Coroutine.h"
namespace hf3fs::client::cli {
class Dispatcher;
CoTryTask<void> registerBenchHandler(Dispatcher &dispatcher);
} // namespace hf3fs::client::cli
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.