text stringlengths 1 24.5M |
|---|
#include "shared/vkRenderers/VulkanModelRenderer.h"
#include "shared/EasyProfilerWrapper.h"
#include <glm/glm.hpp>
#include <glm/ext.hpp>
using glm::mat4;
static constexpr VkClearColorValue clearValueColor = { 1.0f, 1.0f, 1.0f, 1.0f };
bool ModelRenderer::createDescriptorSet(VulkanRenderDevice& vkDev, uint32_t unifo... |
#pragma once
#include "shared/vkRenderers/VulkanRendererBase.h"
class ModelRenderer: public RendererBase
{
public:
ModelRenderer(VulkanRenderDevice& vkDev, const char* modelFile, const char* textureFile, uint32_t uniformDataSize);
ModelRenderer(VulkanRenderDevice& vkDev, bool useDepth, VkBuffer storageBuffer, VkDev... |
#include "shared/vkRenderers/VulkanMultiMeshRenderer.h"
bool MultiMeshRenderer::createDescriptorSet(VulkanRenderDevice& vkDev)
{
const std::array<VkDescriptorSetLayoutBinding, 5> bindings = {
descriptorSetLayoutBinding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT),
/* vertices [part of this.st... |
#pragma once
#include "shared/vkRenderers/VulkanRendererBase.h"
#include <glm/glm.hpp>
#include <glm/ext.hpp>
using glm::mat4;
#include "shared/scene/VtxData.h"
class MultiMeshRenderer: public RendererBase
{
public:
virtual void fillCommandBuffer(VkCommandBuffer commandBuffer, size_t currentImage) override;
Mult... |
#include "shared/vkRenderers/VulkanPBRModelRenderer.h"
#include <glm/glm.hpp>
#include <glm/ext.hpp>
using glm::mat4;
#include <glad/gl.h>
#include <gli/gli.hpp>
#include <gli/texture2d.hpp>
#include <gli/load_ktx.hpp>
static constexpr VkClearColorValue clearValueColor = { 1.0f, 1.0f, 1.0f, 1.0f };
bool PBRModelRen... |
#pragma once
#include "shared/vkRenderers/VulkanRendererBase.h"
class PBRModelRenderer: public RendererBase
{
public:
PBRModelRenderer(VulkanRenderDevice& vkDev,
uint32_t uniformBufferSize,
const char* modelFile,
const char* texAOFile,
const char* texEmissiveFile,
const char* texAlbedoFile,
const c... |
#include "shared/vkRenderers/VulkanQuadRenderer.h"
static constexpr int MAX_QUADS = 256;
void VulkanQuadRenderer::clear() { quads_.clear(); }
void VulkanQuadRenderer::quad(float x1, float y1, float x2, float y2)
{
VertexData v1 { { x1, y1, 0 }, { 0, 0 } };
VertexData v2 { { x2, y1, 0 }, { 1, 0 } };
VertexData v3 ... |
#pragma once
#include "shared/vkRenderers/VulkanRendererBase.h"
#include <string>
#include <stdio.h>
#include <glm/glm.hpp>
#include <glm/ext.hpp>
using glm::mat4;
using glm::vec2;
using glm::vec3;
using glm::vec4;
class VulkanQuadRenderer: public RendererBase
{
public:
VulkanQuadRenderer(VulkanRenderDevice& vkDev,... |
#include "shared/vkRenderers/VulkanRendererBase.h"
#include <stdio.h>
RendererBase::~RendererBase()
{
for (auto buf : uniformBuffers_)
vkDestroyBuffer(device_, buf, nullptr);
for (auto mem : uniformBuffersMemory_)
vkFreeMemory(device_, mem, nullptr);
vkDestroyDescriptorSetLayout(device_, descriptorSetLayout_,... |
#pragma once
#include "shared/UtilsVulkan.h"
class RendererBase
{
public:
explicit RendererBase(const VulkanRenderDevice& vkDev, VulkanImage depthTexture)
: device_(vkDev.device)
, framebufferWidth_(vkDev.framebufferWidth)
, framebufferHeight_(vkDev.framebufferHeight)
, depthTexture_(depthTexture)
{}
virtual ~... |
#include "shared/vkRenderers/VulkanSingleQuad.h"
#include <stdio.h>
bool VulkanSingleQuadRenderer::createDescriptorSet(VulkanRenderDevice& vkDev, VkImageLayout desiredLayout)
{
VkDescriptorSetLayoutBinding binding =
descriptorSetLayoutBinding(0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BI... |
#pragma once
#include "shared/vkRenderers/VulkanRendererBase.h"
#include <glm/glm.hpp>
#include <glm/ext.hpp>
using glm::mat4;
using glm::vec2;
using glm::vec3;
using glm::vec4;
class VulkanSingleQuadRenderer: public RendererBase
{
public:
VulkanSingleQuadRenderer(VulkanRenderDevice& vkDev, VulkanImage tex, VkSampl... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include "choi_evaluator.h"
ChoiEvaluator::ChoiEvaluator(const std::string &name,
const std::filesystem::path &dataset_directory,
const std::filesystem::path &e... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_EXAMPLES_CHOI_EVALUATOR_H_
#define ICG_EXAMPLES_CHOI_EVALUATOR_H_
#include <icg/body.h>
#include <icg/common.h>
#include <icg/depth_modality.h>
#include <icg/depth_model.h>
#include <icg/loader_camera.h>
#i... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include "choi_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
std::filesystem::path result_path{"/your/... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include "opt_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
std::filesystem::path result_path{"/your/p... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include "rbot_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
std::filesystem::path result_directory{"/... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include "ycb_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
std::filesystem::path result_path{"/your/p... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include "opt_evaluator.h"
OPTEvaluator::OPTEvaluator(const std::string &name,
const std::filesystem::path &dataset_directory,
const std::filesystem::path &external... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_EXAMPLES_OPT_EVALUATOR_H_
#define ICG_EXAMPLES_OPT_EVALUATOR_H_
#include <icg/body.h>
#include <icg/common.h>
#include <icg/depth_modality.h>
#include <icg/depth_model.h>
#include <icg/loader_camera.h>
#inc... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include "choi_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
// Dataset configuration
std::vector<s... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include "opt_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
// Dataset configuration
std::vector<st... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include "rbot_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
// Dataset configuration
std::vector<s... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include "ycb_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
constexpr bool kEvaluateSundermeyer = fal... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include "rbot_evaluator.h"
RBOTEvaluator::RBOTEvaluator(const std::string &name,
const std::filesystem::path &dataset_directory,
const std::filesystem::path &e... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_EXAMPLES_RBOT_EVALUATOR_H_
#define ICG_EXAMPLES_RBOT_EVALUATOR_H_
#include <icg/basic_depth_renderer.h>
#include <icg/body.h>
#include <icg/common.h>
#include <icg/loader_camera.h>
#include <icg/modality.h>... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <filesystem/filesystem.h>
#include <icg/azure_kinect_camera.h>
#include <icg/image_viewer.h>
#include <icg/tracker.h>
#include <memory>
#include <string>
int main(int argc, char *argv[]) {
if (argc != 2) {
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <filesystem/filesystem.h>
#include <icg/generator.h>
#include <icg/tracker.h>
int main(int argc, char *argv[]) {
if (argc != 2) {
std::cerr << "Not enough arguments: Provide configfile_path";
return ... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <filesystem/filesystem.h>
#include <icg/azure_kinect_camera.h>
#include <icg/basic_depth_renderer.h>
#include <icg/body.h>
#include <icg/common.h>
#include <icg/depth_modality.h>
#include <icg/depth_model.h>
#i... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <filesystem/filesystem.h>
#include <icg/basic_depth_renderer.h>
#include <icg/body.h>
#include <icg/common.h>
#include <icg/loader_camera.h>
#include <icg/manual_detector.h>
#include <icg/normal_viewer.h>
#incl... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include "ycb_evaluator.h"
YCBEvaluator::YCBEvaluator(const std::string &name,
const std::filesystem::path &dataset_directory,
const std::filesystem::path &external... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_EXAMPLES_YCB_EVALUATOR_H_
#define ICG_EXAMPLES_YCB_EVALUATOR_H_
#include <icg/basic_depth_renderer.h>
#include <icg/body.h>
#include <icg/common.h>
#include <icg/depth_modality.h>
#include <icg/depth_model.... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_AZURE_KINECT_CAMERA_H_
#define ICG_INCLUDE_ICG_AZURE_KINECT_CAMERA_H_
#include <filesystem/filesystem.h>
#include <icg/camera.h>
#include <icg/common.h>
#include <chrono>
#include <iostream>
#i... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_BASIC_DEPTH_RENDERER_H_
#define ICG_INCLUDE_ICG_BASIC_DEPTH_RENDERER_H_
#include <icg/body.h>
#include <icg/camera.h>
#include <icg/common.h>
#include <icg/renderer.h>
#include <icg/renderer_geo... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_BODY_H_
#define ICG_INCLUDE_ICG_BODY_H_
#include <icg/common.h>
#include <filesystem/filesystem.h>
#include <Eigen/Dense>
#include <Eigen/Geometry>
#include <array>
#include <iostream>
#include... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_CAMERA_H_
#define ICG_INCLUDE_ICG_CAMERA_H_
#include <filesystem/filesystem.h>
#include <icg/common.h>
#include <Eigen/Geometry>
#include <fstream>
#include <opencv2/opencv.hpp>
namespace icg ... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_COMMON_H_
#define ICG_INCLUDE_ICG_COMMON_H_
#include <filesystem/filesystem.h>
#include <Eigen/Dense>
#include <Eigen/Geometry>
#include <fstream>
#include <opencv2/opencv.hpp>
#include <string... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_DEPTH_MODALITY_H_
#define ICG_INCLUDE_ICG_DEPTH_MODALITY_H_
#include <filesystem/filesystem.h>
#include <icg/body.h>
#include <icg/camera.h>
#include <icg/common.h>
#include <icg/depth_model.h>
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_DEPTH_MODEL_H_
#define ICG_INCLUDE_ICG_DEPTH_MODEL_H_
#include <filesystem/filesystem.h>
#include <icg/body.h>
#include <icg/common.h>
#include <icg/model.h>
#include <icg/normal_renderer.h>
#in... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_DETECTOR_H_
#define ICG_INCLUDE_ICG_DETECTOR_H_
#include <icg/body.h>
#include <icg/camera.h>
#include <icg/common.h>
namespace icg {
/**
* \brief Abstract class that is able to set the pose ... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_GENERATOR_H_
#define ICG_INCLUDE_ICG_GENERATOR_H_
#ifdef USE_REALSENSE
#include <icg/realsense_camera.h>
#endif
#ifdef USE_AZURE_KINECT
#include <icg/azure_kinect_camera.h>
#endif
#include <icg/... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_IMAGE_VIEWER_H_
#define ICG_INCLUDE_ICG_IMAGE_VIEWER_H_
#include <icg/camera.h>
#include <icg/common.h>
#include <icg/viewer.h>
#include <memory>
#include <opencv2/opencv.hpp>
#include <string>... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_LOADER_CAMERA_H_
#define ICG_INCLUDE_ICG_LOADER_CAMERA_H_
#include <filesystem/filesystem.h>
#include <icg/camera.h>
#include <icg/common.h>
#include <fstream>
#include <iostream>
#include <ope... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_MANUAL_DETECTOR_H_
#define ICG_INCLUDE_ICG_MANUAL_DETECTOR_H_
#include <icg/body.h>
#include <icg/camera.h>
#include <icg/common.h>
#include <icg/detector.h>
#include <filesystem/filesystem.h>
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_MODALITY_H_
#define ICG_INCLUDE_ICG_MODALITY_H_
#include <filesystem/filesystem.h>
#include <icg/body.h>
#include <icg/camera.h>
#include <icg/common.h>
#include <icg/model.h>
#include <filesys... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_MODEL_H_
#define ICG_INCLUDE_ICG_MODEL_H_
#include <filesystem/filesystem.h>
#include <icg/body.h>
#include <icg/common.h>
#include <icg/normal_renderer.h>
#include <icg/renderer_geometry.h>
#in... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_NORMAL_RENDERER_H_
#define ICG_INCLUDE_ICG_NORMAL_RENDERER_H_
#include <icg/body.h>
#include <icg/camera.h>
#include <icg/common.h>
#include <icg/renderer.h>
#include <icg/renderer_geometry.h>
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_NORMAL_VIEWER_H_
#define ICG_INCLUDE_ICG_NORMAL_VIEWER_H_
#include <icg/camera.h>
#include <icg/common.h>
#include <icg/normal_renderer.h>
#include <icg/renderer_geometry.h>
#include <icg/viewer... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_OPTIMIZER_H_
#define ICG_INCLUDE_ICG_OPTIMIZER_H_
#include <icg/body.h>
#include <icg/common.h>
#include <icg/modality.h>
#include <Eigen/Dense>
#include <Eigen/Geometry>
#include <iostream>
#i... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_PUBLISHER_H_
#define ICG_INCLUDE_ICG_PUBLISHER_H_
#include <icg/common.h>
namespace icg {
/**
* \brief Abstract class that defines a publisher that can be used to
* publish any data.
*/
cla... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_REALSENSE_CAMERA_H_
#define ICG_INCLUDE_ICG_REALSENSE_CAMERA_H_
#include <filesystem/filesystem.h>
#include <icg/camera.h>
#include <icg/common.h>
#include <chrono>
#include <iostream>
#include... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_REFINER_H_
#define ICG_INCLUDE_ICG_REFINER_H_
#include <icg/body.h>
#include <icg/modality.h>
#include <icg/optimizer.h>
#include <string>
#include <vector>
namespace icg {
/**
* \brief Clas... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_REGION_MODALITY_H_
#define ICG_INCLUDE_ICG_REGION_MODALITY_H_
#include <filesystem/filesystem.h>
#include <icg/body.h>
#include <icg/camera.h>
#include <icg/common.h>
#include <icg/modality.h>
#... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_REGION_MODEL_H_
#define ICG_INCLUDE_ICG_REGION_MODEL_H_
#include <filesystem/filesystem.h>
#include <icg/body.h>
#include <icg/common.h>
#include <icg/model.h>
#include <icg/normal_renderer.h>
#... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_RENDERER_H_
#define ICG_INCLUDE_ICG_RENDERER_H_
#include <icg/camera.h>
#include <icg/common.h>
#include <icg/renderer_geometry.h>
#include <Eigen/Dense>
#include <Eigen/Geometry>
#include <ios... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_RENDERER_GEOMETRY_H_
#define ICG_INCLUDE_ICG_RENDERER_GEOMETRY_H_
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <icg/body.h>
#include <icg/common.h>
#include <filesystem/filesystem.h>
#... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_STATIC_DETECTOR_H_
#define ICG_INCLUDE_ICG_STATIC_DETECTOR_H_
#include <icg/body.h>
#include <icg/common.h>
#include <icg/detector.h>
#include <filesystem/filesystem.h>
#include <Eigen/Geometry... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_TRACKER_H_
#define ICG_INCLUDE_ICG_TRACKER_H_
#include <icg/body.h>
#include <icg/camera.h>
#include <icg/common.h>
#include <icg/detector.h>
#include <icg/modality.h>
#include <icg/optimizer.h>... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_VIEWER_H_
#define ICG_INCLUDE_ICG_VIEWER_H_
#include <filesystem/filesystem.h>
#include <icg/camera.h>
#include <icg/common.h>
#include <icg/renderer_geometry.h>
#include <memory>
#include <str... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/azure_kinect_camera.h>
namespace icg {
AzureKinect &AzureKinect::GetInstance() {
static AzureKinect kinect;
return kinect;
}
AzureKinect::~AzureKinect() {
if (initial_set_up_) {
device_.stop_c... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/basic_depth_renderer.h>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
namespace icg {
std::string BasicDepthRendererCore::vertex_shader_code_ =
"#version 330 core\n"
"layout(location = 0) in vec3... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/body.h>
#define TINYOBJLOADER_IMPLEMENTATION
#include <tiny_obj_loader/tiny_obj_loader.h>
namespace icg {
Body::Body(const std::string &name, const std::filesystem::path &geometry_path,
float... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/camera.h>
#include <opencv2/core/eigen.hpp>
namespace icg {
void Camera::set_name(const std::string &name) { name_ = name; }
void Camera::set_metafile_path(const std::filesystem::path &metafile_path) {... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/common.h>
#include <opencv2/core/eigen.hpp>
namespace icg {
bool Equivalent(const std::filesystem::path &path1,
const std::filesystem::path &path2) {
try {
return std::filesystem::... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/depth_modality.h>
namespace icg {
DepthModality::DepthModality(
const std::string &name, const std::shared_ptr<Body> &body_ptr,
const std::shared_ptr<DepthCamera> &depth_camera_ptr,
const std... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/depth_model.h>
namespace icg {
DepthModel::DepthModel(const std::string &name,
const std::shared_ptr<Body> &body_ptr,
const std::filesystem::path &model_path... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/detector.h>
namespace icg {
void Detector::set_name(const std::string &name) { name_ = name; }
void Detector::set_metafile_path(const std::filesystem::path &metafile_path) {
metafile_path_ = metafile_... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/generator.h>
namespace icg {
std::string Name(const cv::FileNode& file_node) {
return file_node["name"].string();
}
std::filesystem::path MetafilePath(
const cv::FileNode& file_node,
const std... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/image_viewer.h>
namespace icg {
ImageColorViewer::ImageColorViewer(
const std::string &name,
const std::shared_ptr<ColorCamera> &color_camera_ptr)
: ColorViewer{name, color_camera_ptr} {}
Im... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/loader_camera.h>
#include <opencv2/core/eigen.hpp>
namespace icg {
LoaderColorCamera::LoaderColorCamera(
const std::string &name, const std::filesystem::path &load_directory,
const Intrinsics &i... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/manual_detector.h>
#include <opencv2/core/eigen.hpp>
namespace icg {
PointDetector::PointDetector(const cv::Mat& image,
const std::string& window_name,
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/modality.h>
namespace icg {
void Modality::set_name(const std::string &name) { name_ = name; }
void Modality::set_metafile_path(const std::filesystem::path &metafile_path) {
metafile_path_ = metafile_... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/model.h>
namespace icg {
void Model::set_name(const std::string &name) { name_ = name; }
void Model::set_metafile_path(const std::filesystem::path &metafile_path) {
metafile_path_ = metafile_path;
s... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/normal_renderer.h>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
namespace icg {
std::string NormalRendererCore::vertex_shader_code_ =
"#version 330 core\n"
"layout(location = 0) in vec3 aPos;\n"... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/normal_viewer.h>
namespace icg {
cv::Mat CalculateAlphaBlend(const cv::Mat &camera_image,
const cv::Mat &renderer_image, float opacity) {
// Declare variables
cv::Mat imag... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/optimizer.h>
namespace icg {
Optimizer::Optimizer(const std::string &name, float tikhonov_parameter_rotation,
float tikhonov_parameter_translation)
: name_{name},
tikhonov_... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/publisher.h>
namespace icg {
void Publisher::set_name(const std::string &name) { name_ = name; }
void Publisher::set_metafile_path(const std::filesystem::path &metafile_path) {
metafile_path_ = metafi... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/realsense_camera.h>
namespace icg {
RealSense &RealSense::GetInstance() {
static RealSense realsense;
return realsense;
}
RealSense::~RealSense() {
if (initial_set_up_) {
pipe_.stop();
}
}
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/refiner.h>
namespace icg {
Refiner::Refiner(const std::string &name, int n_corr_iterations,
int n_update_iterations, int visualization_time)
: name_{name},
n_corr_iterations_{n... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/region_modality.h>
namespace icg {
RegionModality::RegionModality(
const std::string &name, const std::shared_ptr<Body> &body_ptr,
const std::shared_ptr<ColorCamera> &color_camera_ptr,
const ... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/region_model.h>
namespace icg {
RegionModel::RegionModel(const std::string &name,
const std::shared_ptr<Body> &body_ptr,
const std::filesystem::path &mod... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/renderer.h>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
namespace icg {
bool CreateShaderProgram(RendererGeometry *renderer_geometry,
const char *vertex_shader_code,
... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/renderer_geometry.h>
namespace icg {
int RendererGeometry::n_instances_ = 0;
RendererGeometry::RendererGeometry(const std::string &name) : name_{name} {}
RendererGeometry::~RendererGeometry() {
if (i... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/static_detector.h>
namespace icg {
StaticDetector::StaticDetector(const std::string &name,
const std::shared_ptr<Body> &body_ptr,
const Trans... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/tracker.h>
namespace icg {
Tracker::Tracker(const std::string &name, int n_corr_iterations,
int n_update_iterations, bool synchronize_cameras,
const std::chrono::millise... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#include <icg/viewer.h>
namespace icg {
void Viewer::set_name(const std::string &name) { name_ = name; }
void Viewer::set_metafile_path(const std::filesystem::path &metafile_path) {
metafile_path_ = metafile_path;
... |
// Copyright (c) 2018 BrainStone
#ifndef INCLUDE_STD_FILESYSTEM_EXPERIMENTAL
// Check for feature test macro for <filesystem>
# if defined(__cpp_lib_filesystem)
# define INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 0
// Check for feature test macro for <experimental/filesystem>
# elif defined(__cpp_lib_experimental_... |
/***********************************************************************
* Software License Agreement (BSD License)
*
* Copyright 2011-16 Jose Luis Blanco (joseluisblancoc@gmail.com).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted pro... |
/***********************************************************************
* 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) 2023 Manuel Stoiber, German Aerospace Center (DLR)
#include "choi_evaluator.h"
ChoiEvaluator::ChoiEvaluator(const std::string &name,
const std::filesystem::path &dataset_directory,
const std::filesystem::path &e... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2023 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef M3T_EXAMPLES_CHOI_EVALUATOR_H_
#define M3T_EXAMPLES_CHOI_EVALUATOR_H_
#include <m3t/body.h>
#include <m3t/common.h>
#include <m3t/depth_modality.h>
#include <m3t/depth_model.h>
#include <m3t/link.h>
#include <m... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2023 Manuel Stoiber, German Aerospace Center (DLR)
#include <m3t/constraint.h>
#include <m3t/link.h>
#include <m3t/optimizer.h>
#include <Eigen/Geometry>
Eigen::Vector3f RandomVector(std::uniform_real_distribution<float>* dis,
std::mt19937... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2023 Manuel Stoiber, German Aerospace Center (DLR)
#include "choi_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
std::filesystem::path result_path{"/your/... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2023 Manuel Stoiber, German Aerospace Center (DLR)
#include "opt_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
std::filesystem::path result_path{"/your/p... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2023 Manuel Stoiber, German Aerospace Center (DLR)
#include "rbot_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
std::filesystem::path result_directory{"/... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2023 Manuel Stoiber, German Aerospace Center (DLR)
#include "rtb_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
std::filesystem::path result_path{"/your/p... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2023 Manuel Stoiber, German Aerospace Center (DLR)
#include "ycb_evaluator.h"
int main() {
// Directories
std::filesystem::path dataset_directory{"/your/path/"};
std::filesystem::path external_directory{"/your/path/"};
std::filesystem::path result_path{"/your/p... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2023 Manuel Stoiber, German Aerospace Center (DLR)
#include <m3t/constraint.h>
#include <m3t/link.h>
#include <m3t/optimizer.h>
#include <Eigen/Geometry>
// Script that evaluates the convergence of rotational constraints
int main(int argc, char* argv[]) {
// Paramet... |
// SPDX-License-Identifier: MIT
// Copyright (c) 2023 Manuel Stoiber, German Aerospace Center (DLR)
#include "opt_evaluator.h"
OPTEvaluator::OPTEvaluator(const std::string &name,
const std::filesystem::path &dataset_directory,
const std::filesystem::path &external... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.