sse-align.cpp
Go to the documentation of this file.
1 // License: Apache 2.0. See LICENSE file in root directory.
2 // Copyright(c) 2019 Intel Corporation. All Rights Reserved.
3 #ifdef __SSSE3__
4 
5 #include "sse-align.h"
6 #include <tmmintrin.h> // For SSE3 intrinsic used in unpack_yuy2_sse
7 #include "../include/librealsense2/hpp/rs_sensor.hpp"
8 #include "../include/librealsense2/hpp/rs_processing.hpp"
9 #include "../include/librealsense2/rsutil.h"
10 
11 #include "core/video.h"
12 #include "proc/synthetic-stream.h"
13 #include "environment.h"
14 #include "stream.h"
15 
16 using namespace librealsense;
17 
18 template<int N> struct bytes { byte b[N]; };
19 
20 bool is_special_resolution(const rs2_intrinsics& depth, const rs2_intrinsics& to)
21 {
22  if ((depth.width == 640 && depth.height == 240 && to.width == 320 && to.height == 180) ||
23  (depth.width == 640 && depth.height == 480 && to.width == 640 && to.height == 360))
24  return true;
25  return false;
26 }
27 
28 template<rs2_distortion dist>
29 inline void distorte_x_y(const __m128 & x, const __m128 & y, __m128 * distorted_x, __m128 * distorted_y, const rs2_intrinsics& to)
30 {
31  *distorted_x = x;
32  *distorted_y = y;
33 }
34 template<>
35 inline void distorte_x_y<RS2_DISTORTION_MODIFIED_BROWN_CONRADY>(const __m128& x, const __m128& y, __m128* distorted_x, __m128* distorted_y, const rs2_intrinsics& to)
36 {
37  __m128 c[5];
38  auto one = _mm_set_ps1(1);
39  auto two = _mm_set_ps1(2);
40 
41  for (int i = 0; i < 5; ++i)
42  {
43  c[i] = _mm_set_ps1(to.coeffs[i]);
44  }
45  auto r2_0 = _mm_add_ps(_mm_mul_ps(x, x), _mm_mul_ps(y, y));
46  auto r3_0 = _mm_add_ps(_mm_mul_ps(c[1], _mm_mul_ps(r2_0, r2_0)), _mm_mul_ps(c[4], _mm_mul_ps(r2_0, _mm_mul_ps(r2_0, r2_0))));
47  auto f_0 = _mm_add_ps(one, _mm_add_ps(_mm_mul_ps(c[0], r2_0), r3_0));
48 
49  auto x_f0 = _mm_mul_ps(x, f_0);
50  auto y_f0 = _mm_mul_ps(y, f_0);
51 
52  auto r4_0 = _mm_mul_ps(c[3], _mm_add_ps(r2_0, _mm_mul_ps(two, _mm_mul_ps(x_f0, x_f0))));
53  auto d_x0 = _mm_add_ps(x_f0, _mm_add_ps(_mm_mul_ps(two, _mm_mul_ps(c[2], _mm_mul_ps(x_f0, y_f0))), r4_0));
54 
55  auto r5_0 = _mm_mul_ps(c[2], _mm_add_ps(r2_0, _mm_mul_ps(two, _mm_mul_ps(y_f0, y_f0))));
56  auto d_y0 = _mm_add_ps(y_f0, _mm_add_ps(_mm_mul_ps(two, _mm_mul_ps(c[3], _mm_mul_ps(x_f0, y_f0))), r4_0));
57 
58  *distorted_x = d_x0;
59  *distorted_y = d_y0;
60 }
61 
62 
63 template<rs2_distortion dist>
64 inline void get_texture_map_sse(const uint16_t * depth,
65  float depth_scale,
66  const unsigned int size,
67  const float * pre_compute_x, const float * pre_compute_y,
68  byte * pixels_ptr_int,
69  const rs2_intrinsics& to,
70  const rs2_extrinsics& from_to_other)
71 {
72  //mask for shuffle
73  const __m128i mask0 = _mm_set_epi8((char)0xff, (char)0xff, (char)7, (char)6, (char)0xff, (char)0xff, (char)5, (char)4,
74  (char)0xff, (char)0xff, (char)3, (char)2, (char)0xff, (char)0xff, (char)1, (char)0);
75  const __m128i mask1 = _mm_set_epi8((char)0xff, (char)0xff, (char)15, (char)14, (char)0xff, (char)0xff, (char)13, (char)12,
76  (char)0xff, (char)0xff, (char)11, (char)10, (char)0xff, (char)0xff, (char)9, (char)8);
77 
78  auto scale = _mm_set_ps1(depth_scale);
79 
80  auto mapx = pre_compute_x;
81  auto mapy = pre_compute_y;
82 
83  auto res = reinterpret_cast<__m128i*>(pixels_ptr_int);
84 
85  __m128 r[9];
86  __m128 t[3];
87  __m128 c[5];
88 
89  for (int i = 0; i < 9; ++i)
90  {
91  r[i] = _mm_set_ps1(from_to_other.rotation[i]);
92  }
93  for (int i = 0; i < 3; ++i)
94  {
95  t[i] = _mm_set_ps1(from_to_other.translation[i]);
96  }
97  for (int i = 0; i < 5; ++i)
98  {
99  c[i] = _mm_set_ps1(to.coeffs[i]);
100  }
101  auto zero = _mm_set_ps1(0);
102  auto fx = _mm_set_ps1(to.fx);
103  auto fy = _mm_set_ps1(to.fy);
104  auto ppx = _mm_set_ps1(to.ppx);
105  auto ppy = _mm_set_ps1(to.ppy);
106 
107  for (unsigned int i = 0; i < size; i += 8)
108  {
109  auto x0 = _mm_load_ps(mapx + i);
110  auto x1 = _mm_load_ps(mapx + i + 4);
111 
112  auto y0 = _mm_load_ps(mapy + i);
113  auto y1 = _mm_load_ps(mapy + i + 4);
114 
115 
116  __m128i d = _mm_load_si128((__m128i const*)(depth + i)); //d7 d7 d6 d6 d5 d5 d4 d4 d3 d3 d2 d2 d1 d1 d0 d0
117 
118  //split the depth pixel to 2 registers of 4 floats each
119  __m128i d0 = _mm_shuffle_epi8(d, mask0); // 00 00 d3 d3 00 00 d2 d2 00 00 d1 d1 00 00 d0 d0
120  __m128i d1 = _mm_shuffle_epi8(d, mask1); // 00 00 d7 d7 00 00 d6 d6 00 00 d5 d5 00 00 d4 d4
121 
122  __m128 depth0 = _mm_cvtepi32_ps(d0); //convert depth to float
123  __m128 depth1 = _mm_cvtepi32_ps(d1); //convert depth to float
124 
125  depth0 = _mm_mul_ps(depth0, scale);
126  depth1 = _mm_mul_ps(depth1, scale);
127 
128  auto p0x = _mm_mul_ps(depth0, x0);
129  auto p0y = _mm_mul_ps(depth0, y0);
130 
131  auto p1x = _mm_mul_ps(depth1, x1);
132  auto p1y = _mm_mul_ps(depth1, y1);
133 
134  auto p_x0 = _mm_add_ps(_mm_mul_ps(r[0], p0x), _mm_add_ps(_mm_mul_ps(r[3], p0y), _mm_add_ps(_mm_mul_ps(r[6], depth0), t[0])));
135  auto p_y0 = _mm_add_ps(_mm_mul_ps(r[1], p0x), _mm_add_ps(_mm_mul_ps(r[4], p0y), _mm_add_ps(_mm_mul_ps(r[7], depth0), t[1])));
136  auto p_z0 = _mm_add_ps(_mm_mul_ps(r[2], p0x), _mm_add_ps(_mm_mul_ps(r[5], p0y), _mm_add_ps(_mm_mul_ps(r[8], depth0), t[2])));
137 
138  auto p_x1 = _mm_add_ps(_mm_mul_ps(r[0], p1x), _mm_add_ps(_mm_mul_ps(r[3], p1y), _mm_add_ps(_mm_mul_ps(r[6], depth1), t[0])));
139  auto p_y1 = _mm_add_ps(_mm_mul_ps(r[1], p1x), _mm_add_ps(_mm_mul_ps(r[4], p1y), _mm_add_ps(_mm_mul_ps(r[7], depth1), t[1])));
140  auto p_z1 = _mm_add_ps(_mm_mul_ps(r[2], p1x), _mm_add_ps(_mm_mul_ps(r[5], p1y), _mm_add_ps(_mm_mul_ps(r[8], depth1), t[2])));
141 
142  p_x0 = _mm_div_ps(p_x0, p_z0);
143  p_y0 = _mm_div_ps(p_y0, p_z0);
144 
145  p_x1 = _mm_div_ps(p_x1, p_z1);
146  p_y1 = _mm_div_ps(p_y1, p_z1);
147 
148  distorte_x_y<dist>(p_x0, p_y0, &p_x0, &p_y0, to);
149  distorte_x_y<dist>(p_x1, p_y1, &p_x1, &p_y1, to);
150 
151  //zero the x and y if z is zero
152  auto cmp = _mm_cmpneq_ps(depth0, zero);
153  p_x0 = _mm_and_ps(_mm_add_ps(_mm_mul_ps(p_x0, fx), ppx), cmp);
154  p_y0 = _mm_and_ps(_mm_add_ps(_mm_mul_ps(p_y0, fy), ppy), cmp);
155 
156 
157  p_x1 = _mm_add_ps(_mm_mul_ps(p_x1, fx), ppx);
158  p_y1 = _mm_add_ps(_mm_mul_ps(p_y1, fy), ppy);
159 
160  cmp = _mm_cmpneq_ps(depth0, zero);
161  auto half = _mm_set_ps1(0.5);
162  auto u_round0 = _mm_and_ps(_mm_add_ps(p_x0, half), cmp);
163  auto v_round0 = _mm_and_ps(_mm_add_ps(p_y0, half), cmp);
164 
165  auto uuvv1_0 = _mm_shuffle_ps(u_round0, v_round0, _MM_SHUFFLE(1, 0, 1, 0));
166  auto uuvv2_0 = _mm_shuffle_ps(u_round0, v_round0, _MM_SHUFFLE(3, 2, 3, 2));
167 
168  auto res1_0 = _mm_shuffle_ps(uuvv1_0, uuvv1_0, _MM_SHUFFLE(3, 1, 2, 0));
169  auto res2_0 = _mm_shuffle_ps(uuvv2_0, uuvv2_0, _MM_SHUFFLE(3, 1, 2, 0));
170 
171  auto res1_int0 = _mm_cvtps_epi32(res1_0);
172  auto res2_int0 = _mm_cvtps_epi32(res2_0);
173 
174  _mm_stream_si128(&res[0], res1_int0);
175  _mm_stream_si128(&res[1], res2_int0);
176  res += 2;
177 
178  cmp = _mm_cmpneq_ps(depth1, zero);
179  auto u_round1 = _mm_and_ps(_mm_add_ps(p_x1, half), cmp);
180  auto v_round1 = _mm_and_ps(_mm_add_ps(p_y1, half), cmp);
181 
182  auto uuvv1_1 = _mm_shuffle_ps(u_round1, v_round1, _MM_SHUFFLE(1, 0, 1, 0));
183  auto uuvv2_1 = _mm_shuffle_ps(u_round1, v_round1, _MM_SHUFFLE(3, 2, 3, 2));
184 
185  auto res1 = _mm_shuffle_ps(uuvv1_1, uuvv1_1, _MM_SHUFFLE(3, 1, 2, 0));
186  auto res2 = _mm_shuffle_ps(uuvv2_1, uuvv2_1, _MM_SHUFFLE(3, 1, 2, 0));
187 
188  auto res1_int1 = _mm_cvtps_epi32(res1);
189  auto res2_int1 = _mm_cvtps_epi32(res2);
190 
191  _mm_stream_si128(&res[0], res1_int1);
192  _mm_stream_si128(&res[1], res2_int1);
193  res += 2;
194  }
195 }
196 
197 image_transform::image_transform(const rs2_intrinsics& from, float depth_scale)
198  :_depth(from),
199  _depth_scale(depth_scale),
200  _pixel_top_left_int(from.width*from.height),
201  _pixel_bottom_right_int(from.width*from.height)
202 {
203 }
204 
205 void image_transform::pre_compute_x_y_map_corners()
206 {
207  pre_compute_x_y_map(_pre_compute_map_x_top_left, _pre_compute_map_y_top_left, -0.5f);
208  pre_compute_x_y_map(_pre_compute_map_x_bottom_right, _pre_compute_map_y_bottom_right, 0.5f);
209 }
210 
211 void image_transform::pre_compute_x_y_map(std::vector<float>& pre_compute_map_x,
212  std::vector<float>& pre_compute_map_y,
213  float offset)
214 {
215  pre_compute_map_x.resize(_depth.width*_depth.height);
216  pre_compute_map_y.resize(_depth.width*_depth.height);
217 
218  for (int h = 0; h < _depth.height; ++h)
219  {
220  for (int w = 0; w < _depth.width; ++w)
221  {
222  const float pixel[] = { (float)w + offset, (float)h + offset };
223 
224  float x = (pixel[0] - _depth.ppx) / _depth.fx;
225  float y = (pixel[1] - _depth.ppy) / _depth.fy;
226 
227  if (_depth.model == RS2_DISTORTION_INVERSE_BROWN_CONRADY)
228  {
229  float r2 = x * x + y * y;
230  float f = 1 + _depth.coeffs[0] * r2 + _depth.coeffs[1] * r2*r2 + _depth.coeffs[4] * r2*r2*r2;
231  float ux = x * f + 2 * _depth.coeffs[2] * x*y + _depth.coeffs[3] * (r2 + 2 * x*x);
232  float uy = y * f + 2 * _depth.coeffs[3] * x*y + _depth.coeffs[2] * (r2 + 2 * y*y);
233  x = ux;
234  y = uy;
235  }
236 
237  pre_compute_map_x[h*_depth.width + w] = x;
238  pre_compute_map_y[h*_depth.width + w] = y;
239  }
240  }
241 }
242 
243 void image_transform::align_depth_to_other(const uint16_t* z_pixels, uint16_t* dest, int bpp, const rs2_intrinsics& depth, const rs2_intrinsics& to,
244  const rs2_extrinsics& from_to_other)
245 {
246  switch (to.model)
247  {
249  align_depth_to_other_sse<RS2_DISTORTION_MODIFIED_BROWN_CONRADY>(z_pixels, dest, depth, to, from_to_other);
250  break;
251  default:
252  align_depth_to_other_sse(z_pixels, dest, depth, to, from_to_other);
253  break;
254  }
255 }
256 
257 inline void image_transform::move_depth_to_other(const uint16_t* z_pixels, uint16_t* dest, const rs2_intrinsics& to,
258  const std::vector<librealsense::int2>& pixel_top_left_int,
259  const std::vector<librealsense::int2>& pixel_bottom_right_int)
260 {
261  for (int y = 0; y < _depth.height; ++y)
262  {
263  for (int x = 0; x < _depth.width; ++x)
264  {
265  auto depth_pixel_index = y * _depth.width + x;
266  // Skip over depth pixels with the value of zero, we have no depth data so we will not write anything into our aligned images
267  if (z_pixels[depth_pixel_index])
268  {
269  for (int other_y = pixel_top_left_int[depth_pixel_index].y; other_y <= pixel_bottom_right_int[depth_pixel_index].y; ++other_y)
270  {
271  for (int other_x = pixel_top_left_int[depth_pixel_index].x; other_x <= pixel_bottom_right_int[depth_pixel_index].x; ++other_x)
272  {
273  if (other_x < 0 || other_y < 0 || other_x >= to.width || other_y >= to.height)
274  continue;
275  auto other_ind = other_y * to.width + other_x;
276 
277  dest[other_ind] = dest[other_ind] ? std::min(dest[other_ind], z_pixels[depth_pixel_index]) : z_pixels[depth_pixel_index];
278  }
279  }
280  }
281  }
282  }
283 }
284 
285 void image_transform::align_other_to_depth(const uint16_t* z_pixels, const byte* source, byte* dest, int bpp, const rs2_intrinsics& to,
286  const rs2_extrinsics& from_to_other)
287 {
288  switch (to.model)
289  {
292  align_other_to_depth_sse<RS2_DISTORTION_MODIFIED_BROWN_CONRADY>(z_pixels, source, dest, bpp, to, from_to_other);
293  break;
294  default:
295  align_other_to_depth_sse(z_pixels, source, dest, bpp, to, from_to_other);
296  break;
297  }
298 }
299 
300 
301 template<rs2_distortion dist>
302 inline void image_transform::align_depth_to_other_sse(const uint16_t * z_pixels, uint16_t * dest, const rs2_intrinsics& depth, const rs2_intrinsics& to,
303  const rs2_extrinsics& from_to_other)
304 {
305  get_texture_map_sse<dist>(z_pixels, _depth_scale, _depth.height*_depth.width, _pre_compute_map_x_top_left.data(),
306  _pre_compute_map_y_top_left.data(), (byte*)_pixel_top_left_int.data(), to, from_to_other);
307 
308  float fov[2];
309  rs2_fov(&depth, fov);
310  float2 pixels_per_angle_depth = { (float)depth.width / fov[0], (float)depth.height / fov[1] };
311 
312  rs2_fov(&to, fov);
313  float2 pixels_per_angle_target = { (float)to.width / fov[0], (float)to.height / fov[1] };
314 
315  if (pixels_per_angle_depth.x < pixels_per_angle_target.x || pixels_per_angle_depth.y < pixels_per_angle_target.y || is_special_resolution(depth, to))
316  {
317  get_texture_map_sse<dist>(z_pixels, _depth_scale, _depth.height*_depth.width, _pre_compute_map_x_bottom_right.data(),
318  _pre_compute_map_y_bottom_right.data(), (byte*)_pixel_bottom_right_int.data(), to, from_to_other);
319 
320  move_depth_to_other(z_pixels, dest, to, _pixel_top_left_int, _pixel_bottom_right_int);
321  }
322  else
323  {
324  move_depth_to_other(z_pixels, dest, to, _pixel_top_left_int, _pixel_top_left_int);
325  }
326 
327 }
328 
329 template<rs2_distortion dist>
330 inline void image_transform::align_other_to_depth_sse(const uint16_t * z_pixels, const byte * source, byte * dest, int bpp, const rs2_intrinsics& to,
331  const rs2_extrinsics& from_to_other)
332 {
333  get_texture_map_sse<dist>(z_pixels, _depth_scale, _depth.height*_depth.width, _pre_compute_map_x_top_left.data(),
334  _pre_compute_map_y_top_left.data(), (byte*)_pixel_top_left_int.data(), to, from_to_other);
335 
336  std::vector<int2>& bottom_right = _pixel_top_left_int;
337  if (to.height < _depth.height && to.width < _depth.width)
338  {
339  get_texture_map_sse<dist>(z_pixels, _depth_scale, _depth.height*_depth.width, _pre_compute_map_x_bottom_right.data(),
340  _pre_compute_map_y_bottom_right.data(), (byte*)_pixel_bottom_right_int.data(), to, from_to_other);
341 
342  bottom_right = _pixel_bottom_right_int;
343  }
344 
345  switch (bpp)
346  {
347  case 1:
348  move_other_to_depth(z_pixels, reinterpret_cast<const bytes<1>*>(source), reinterpret_cast<bytes<1>*>(dest), to,
349  _pixel_top_left_int, bottom_right);
350  break;
351  case 2:
352  move_other_to_depth(z_pixels, reinterpret_cast<const bytes<2>*>(source), reinterpret_cast<bytes<2>*>(dest), to,
353  _pixel_top_left_int, bottom_right);
354  break;
355  case 3:
356  move_other_to_depth(z_pixels, reinterpret_cast<const bytes<3>*>(source), reinterpret_cast<bytes<3>*>(dest), to,
357  _pixel_top_left_int, bottom_right);
358  break;
359  case 4:
360  move_other_to_depth(z_pixels, reinterpret_cast<const bytes<4>*>(source), reinterpret_cast<bytes<4>*>(dest), to,
361  _pixel_top_left_int, bottom_right);
362  break;
363  default:
364  break;
365  }
366 }
367 
368 template<class T >
369 void image_transform::move_other_to_depth(const uint16_t* z_pixels,
370  const T* source,
371  T* dest, const rs2_intrinsics& to,
372  const std::vector<librealsense::int2>& pixel_top_left_int,
373  const std::vector<librealsense::int2>& pixel_bottom_right_int)
374 {
375  // Iterate over the pixels of the depth image
376  for (int y = 0; y < _depth.height; ++y)
377  {
378  for (int x = 0; x < _depth.width; ++x)
379  {
380  auto depth_pixel_index = y * _depth.width + x;
381  // Skip over depth pixels with the value of zero, we have no depth data so we will not write anything into our aligned images
382  if (z_pixels[depth_pixel_index])
383  {
384  for (int other_y = pixel_top_left_int[depth_pixel_index].y; other_y <= pixel_bottom_right_int[depth_pixel_index].y; ++other_y)
385  {
386  for (int other_x = pixel_top_left_int[depth_pixel_index].x; other_x <= pixel_bottom_right_int[depth_pixel_index].x; ++other_x)
387  {
388  if (other_x < 0 || other_y < 0 || other_x >= to.width || other_y >= to.height)
389  continue;
390  auto other_ind = other_y * to.width + other_x;
391 
392  dest[depth_pixel_index] = source[other_ind];
393  }
394  }
395  }
396  }
397  }
398 }
399 
400 void align_sse::reset_cache(rs2_stream from, rs2_stream to)
401 {
402  _stream_transform = nullptr;
403 }
404 
405 void align_sse::align_z_to_other(rs2::video_frame& aligned, const rs2::video_frame& depth, const rs2::video_stream_profile& other_profile, float z_scale)
406 {
407  byte* aligned_data = reinterpret_cast<byte*>(const_cast<void*>(aligned.get_data()));
408  auto aligned_profile = aligned.get_profile().as<rs2::video_stream_profile>();
409  memset(aligned_data, 0, aligned_profile.height() * aligned_profile.width() * aligned.get_bytes_per_pixel());
410 
412 
413  auto z_intrin = depth_profile.get_intrinsics();
414  auto other_intrin = other_profile.get_intrinsics();
415  auto z_to_other = depth_profile.get_extrinsics_to(other_profile);
416 
417  auto z_pixels = reinterpret_cast<const uint16_t*>(depth.get_data());
418 
419  if (_stream_transform == nullptr)
420  {
421  _stream_transform = std::make_shared<image_transform>(z_intrin, z_scale);
422  _stream_transform->pre_compute_x_y_map_corners();
423  }
424  _stream_transform->align_depth_to_other(z_pixels, reinterpret_cast<uint16_t*>(aligned_data), 2, z_intrin, other_intrin, z_to_other);
425 }
426 
427 void align_sse::align_other_to_z(rs2::video_frame& aligned, const rs2::video_frame& depth, const rs2::video_frame& other, float z_scale)
428 {
429  byte* aligned_data = reinterpret_cast<byte*>(const_cast<void*>(aligned.get_data()));
430  auto aligned_profile = aligned.get_profile().as<rs2::video_stream_profile>();
431  memset(aligned_data, 0, aligned_profile.height() * aligned_profile.width() * aligned.get_bytes_per_pixel());
432 
433  auto depth_profile = depth.get_profile().as<rs2::video_stream_profile>();
434  auto other_profile = other.get_profile().as<rs2::video_stream_profile>();
435 
436  auto z_intrin = depth_profile.get_intrinsics();
437  auto other_intrin = other_profile.get_intrinsics();
438  auto z_to_other = depth_profile.get_extrinsics_to(other_profile);
439 
440  auto z_pixels = reinterpret_cast<const uint16_t*>(depth.get_data());
441  auto other_pixels = reinterpret_cast<const byte*>(other.get_data());
442 
443  if (_stream_transform == nullptr)
444  {
445  _stream_transform = std::make_shared<image_transform>(z_intrin, z_scale);
446  _stream_transform->pre_compute_x_y_map_corners();
447  }
448 
449  _stream_transform->align_other_to_depth(z_pixels, other_pixels, aligned_data, other.get_bytes_per_pixel(), other_intrin, z_to_other);
450 }
451 #endif
GLboolean GLboolean GLboolean b
GLint y
float translation[3]
Definition: rs_sensor.h:99
GLenum GLenum GLenum GLenum GLenum scale
Definition: glext.h:10806
static void rs2_fov(const struct rs2_intrinsics *intrin, float to_fov[2])
Definition: rsutil.h:176
stream_profile get_profile() const
Definition: rs_frame.hpp:557
int get_bytes_per_pixel() const
Definition: rs_frame.hpp:707
GLint GLint GLsizei GLsizei GLsizei depth
const void * get_data() const
Definition: rs_frame.hpp:545
unsigned short uint16_t
Definition: stdint.h:79
float coeffs[5]
Definition: rs_types.h:67
GLdouble GLdouble GLdouble w
d
Definition: rmse.py:171
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:1960
static const int one
float rotation[9]
Definition: rs_sensor.h:98
GLdouble t
GLdouble f
GLsizeiptr size
const GLubyte * c
Definition: glext.h:12690
GLdouble GLdouble r
GLdouble x
GLint GLsizei GLsizei height
GLuint GLfloat x0
Definition: glext.h:9721
rs2_intrinsics get_intrinsics() const
Definition: rs_frame.hpp:238
rs2_stream
Streams are different types of data provided by RealSense devices.
Definition: rs_sensor.h:42
Cross-stream extrinsics: encodes the topology describing how the different devices are oriented...
Definition: rs_sensor.h:96
GLuint GLfloat GLfloat GLfloat x1
Definition: glext.h:9721
rs2_distortion model
Definition: rs_types.h:66
unsigned char byte
Definition: src/types.h:52
int min(int a, int b)
Definition: lz4s.c:73
GLuint GLfloat GLfloat y0
Definition: glext.h:9721
Video stream intrinsics.
Definition: rs_types.h:58
GLsizei GLsizei GLchar * source
LZ4LIB_API char * dest
Definition: lz4.h:438
int i
GLuint res
Definition: glext.h:8856
void align_other_to_depth(byte *other_aligned_to_depth, GET_DEPTH get_depth, const rs2_intrinsics &depth_intrin, const rs2_extrinsics &depth_to_other, const rs2_intrinsics &other_intrin, const byte *other_pixels, rs2_format other_format)
Definition: align.cpp:103
GLdouble y1
GLint GLsizei width
GLintptr offset


librealsense2
Author(s): Sergey Dorodnicov , Doron Hirshberg , Mark Horn , Reagan Lopez , Itay Carpis
autogenerated on Mon May 3 2021 02:50:10