mirror of
https://github.com/facebookresearch/pytorch3d.git
synced 2025-08-06 05:52:49 +08:00
487d4d6607
Summary: Implementation of point to mesh distances. The current diff contains two types: (a) Point to Edge (b) Point to Face ``` Benchmark Avg Time(μs) Peak Time(μs) Iterations -------------------------------------------------------------------------------- POINT_MESH_EDGE_4_100_300_5000_cuda:0 2745 3138 183 POINT_MESH_EDGE_4_100_300_10000_cuda:0 4408 4499 114 POINT_MESH_EDGE_4_100_3000_5000_cuda:0 4978 5070 101 POINT_MESH_EDGE_4_100_3000_10000_cuda:0 9076 9187 56 POINT_MESH_EDGE_4_1000_300_5000_cuda:0 1411 1487 355 POINT_MESH_EDGE_4_1000_300_10000_cuda:0 4829 5030 104 POINT_MESH_EDGE_4_1000_3000_5000_cuda:0 7539 7620 67 POINT_MESH_EDGE_4_1000_3000_10000_cuda:0 12088 12272 42 POINT_MESH_EDGE_8_100_300_5000_cuda:0 3106 3222 161 POINT_MESH_EDGE_8_100_300_10000_cuda:0 8561 8648 59 POINT_MESH_EDGE_8_100_3000_5000_cuda:0 6932 7021 73 POINT_MESH_EDGE_8_100_3000_10000_cuda:0 24032 24176 21 POINT_MESH_EDGE_8_1000_300_5000_cuda:0 5272 5399 95 POINT_MESH_EDGE_8_1000_300_10000_cuda:0 11348 11430 45 POINT_MESH_EDGE_8_1000_3000_5000_cuda:0 17478 17683 29 POINT_MESH_EDGE_8_1000_3000_10000_cuda:0 25961 26236 20 POINT_MESH_EDGE_16_100_300_5000_cuda:0 8244 8323 61 POINT_MESH_EDGE_16_100_300_10000_cuda:0 18018 18071 28 POINT_MESH_EDGE_16_100_3000_5000_cuda:0 19428 19544 26 POINT_MESH_EDGE_16_100_3000_10000_cuda:0 44967 45135 12 POINT_MESH_EDGE_16_1000_300_5000_cuda:0 7825 7937 64 POINT_MESH_EDGE_16_1000_300_10000_cuda:0 18504 18571 28 POINT_MESH_EDGE_16_1000_3000_5000_cuda:0 65805 66132 8 POINT_MESH_EDGE_16_1000_3000_10000_cuda:0 90885 91089 6 -------------------------------------------------------------------------------- Benchmark Avg Time(μs) Peak Time(μs) Iterations -------------------------------------------------------------------------------- POINT_MESH_FACE_4_100_300_5000_cuda:0 1561 1685 321 POINT_MESH_FACE_4_100_300_10000_cuda:0 2818 2954 178 POINT_MESH_FACE_4_100_3000_5000_cuda:0 15893 16018 32 POINT_MESH_FACE_4_100_3000_10000_cuda:0 16350 16439 31 POINT_MESH_FACE_4_1000_300_5000_cuda:0 3179 3278 158 POINT_MESH_FACE_4_1000_300_10000_cuda:0 2353 2436 213 POINT_MESH_FACE_4_1000_3000_5000_cuda:0 16262 16336 31 POINT_MESH_FACE_4_1000_3000_10000_cuda:0 9334 9448 54 POINT_MESH_FACE_8_100_300_5000_cuda:0 4377 4493 115 POINT_MESH_FACE_8_100_300_10000_cuda:0 9728 9822 52 POINT_MESH_FACE_8_100_3000_5000_cuda:0 26428 26544 19 POINT_MESH_FACE_8_100_3000_10000_cuda:0 42238 43031 12 POINT_MESH_FACE_8_1000_300_5000_cuda:0 3891 3982 129 POINT_MESH_FACE_8_1000_300_10000_cuda:0 5363 5429 94 POINT_MESH_FACE_8_1000_3000_5000_cuda:0 20998 21084 24 POINT_MESH_FACE_8_1000_3000_10000_cuda:0 39711 39897 13 POINT_MESH_FACE_16_100_300_5000_cuda:0 5955 6001 84 POINT_MESH_FACE_16_100_300_10000_cuda:0 12082 12144 42 POINT_MESH_FACE_16_100_3000_5000_cuda:0 44996 45176 12 POINT_MESH_FACE_16_100_3000_10000_cuda:0 73042 73197 7 POINT_MESH_FACE_16_1000_300_5000_cuda:0 8292 8374 61 POINT_MESH_FACE_16_1000_300_10000_cuda:0 19442 19506 26 POINT_MESH_FACE_16_1000_3000_5000_cuda:0 36059 36194 14 POINT_MESH_FACE_16_1000_3000_10000_cuda:0 64644 64822 8 -------------------------------------------------------------------------------- ``` Reviewed By: jcjohnson Differential Revision: D20590462 fbshipit-source-id: 42a39837b514a546ac9471bfaff60eefe7fae829
140 lines
4.2 KiB
Plaintext
140 lines
4.2 KiB
Plaintext
// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
|
|
|
|
#pragma once
|
|
#include <thrust/tuple.h>
|
|
|
|
// Set epsilon
|
|
#ifdef _MSC_VER
|
|
#define vEpsilon 1e-8f
|
|
#else
|
|
const auto vEpsilon = 1e-8;
|
|
#endif
|
|
|
|
// Common functions and operators for float2.
|
|
|
|
__device__ inline float2 operator-(const float2& a, const float2& b) {
|
|
return make_float2(a.x - b.x, a.y - b.y);
|
|
}
|
|
|
|
__device__ inline float2 operator+(const float2& a, const float2& b) {
|
|
return make_float2(a.x + b.x, a.y + b.y);
|
|
}
|
|
|
|
__device__ inline float2 operator/(const float2& a, const float2& b) {
|
|
return make_float2(a.x / b.x, a.y / b.y);
|
|
}
|
|
|
|
__device__ inline float2 operator/(const float2& a, const float b) {
|
|
return make_float2(a.x / b, a.y / b);
|
|
}
|
|
|
|
__device__ inline float2 operator*(const float2& a, const float2& b) {
|
|
return make_float2(a.x * b.x, a.y * b.y);
|
|
}
|
|
|
|
__device__ inline float2 operator*(const float a, const float2& b) {
|
|
return make_float2(a * b.x, a * b.y);
|
|
}
|
|
|
|
__device__ inline float dot(const float2& a, const float2& b) {
|
|
return a.x * b.x + a.y * b.y;
|
|
}
|
|
|
|
// Backward pass for the dot product.
|
|
// Args:
|
|
// a, b: Coordinates of two points.
|
|
// grad_dot: Upstream gradient for the output.
|
|
//
|
|
// Returns:
|
|
// tuple of gradients for each of the input points:
|
|
// (float2 grad_a, float2 grad_b)
|
|
//
|
|
__device__ inline thrust::tuple<float2, float2>
|
|
DotBackward(const float2& a, const float2& b, const float& grad_dot) {
|
|
return thrust::make_tuple(grad_dot * b, grad_dot * a);
|
|
}
|
|
|
|
__device__ inline float sum(const float2& a) {
|
|
return a.x + a.y;
|
|
}
|
|
|
|
// Common functions and operators for float3.
|
|
|
|
__device__ inline float3 operator-(const float3& a, const float3& b) {
|
|
return make_float3(a.x - b.x, a.y - b.y, a.z - b.z);
|
|
}
|
|
|
|
__device__ inline float3 operator+(const float3& a, const float3& b) {
|
|
return make_float3(a.x + b.x, a.y + b.y, a.z + b.z);
|
|
}
|
|
|
|
__device__ inline float3 operator/(const float3& a, const float3& b) {
|
|
return make_float3(a.x / b.x, a.y / b.y, a.z / b.z);
|
|
}
|
|
|
|
__device__ inline float3 operator/(const float3& a, const float b) {
|
|
return make_float3(a.x / b, a.y / b, a.z / b);
|
|
}
|
|
|
|
__device__ inline float3 operator*(const float3& a, const float3& b) {
|
|
return make_float3(a.x * b.x, a.y * b.y, a.z * b.z);
|
|
}
|
|
|
|
__device__ inline float3 operator*(const float a, const float3& b) {
|
|
return make_float3(a * b.x, a * b.y, a * b.z);
|
|
}
|
|
|
|
__device__ inline float dot(const float3& a, const float3& b) {
|
|
return a.x * b.x + a.y * b.y + a.z * b.z;
|
|
}
|
|
|
|
__device__ inline float sum(const float3& a) {
|
|
return a.x + a.y + a.z;
|
|
}
|
|
|
|
__device__ inline float3 cross(const float3& a, const float3& b) {
|
|
return make_float3(
|
|
a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
|
|
}
|
|
|
|
__device__ inline thrust::tuple<float3, float3>
|
|
cross_backward(const float3& a, const float3& b, const float3& grad_cross) {
|
|
const float grad_ax = -grad_cross.y * b.z + grad_cross.z * b.y;
|
|
const float grad_ay = grad_cross.x * b.z - grad_cross.z * b.x;
|
|
const float grad_az = -grad_cross.x * b.y + grad_cross.y * b.x;
|
|
const float3 grad_a = make_float3(grad_ax, grad_ay, grad_az);
|
|
|
|
const float grad_bx = grad_cross.y * a.z - grad_cross.z * a.y;
|
|
const float grad_by = -grad_cross.x * a.z + grad_cross.z * a.x;
|
|
const float grad_bz = grad_cross.x * a.y - grad_cross.y * a.x;
|
|
const float3 grad_b = make_float3(grad_bx, grad_by, grad_bz);
|
|
|
|
return thrust::make_tuple(grad_a, grad_b);
|
|
}
|
|
|
|
__device__ inline float norm(const float3& a) {
|
|
return sqrt(dot(a, a));
|
|
}
|
|
|
|
__device__ inline float3 normalize(const float3& a) {
|
|
return a / (norm(a) + vEpsilon);
|
|
}
|
|
|
|
__device__ inline float3 normalize_backward(
|
|
const float3& a,
|
|
const float3& grad_normz) {
|
|
const float a_norm = norm(a) + vEpsilon;
|
|
const float3 out = a / a_norm;
|
|
|
|
const float grad_ax = grad_normz.x * (1.0f - out.x * out.x) / a_norm +
|
|
grad_normz.y * (-out.x * out.y) / a_norm +
|
|
grad_normz.z * (-out.x * out.z) / a_norm;
|
|
const float grad_ay = grad_normz.x * (-out.x * out.y) / a_norm +
|
|
grad_normz.y * (1.0f - out.y * out.y) / a_norm +
|
|
grad_normz.z * (-out.y * out.z) / a_norm;
|
|
const float grad_az = grad_normz.x * (-out.x * out.z) / a_norm +
|
|
grad_normz.y * (-out.y * out.z) / a_norm +
|
|
grad_normz.z * (1.0f - out.z * out.z) / a_norm;
|
|
return make_float3(grad_ax, grad_ay, grad_az);
|
|
}
|