DenseCRFFeatureTerms.h
Go to the documentation of this file.
1 /*
2  * This file is part of ArmarX.
3  *
4  * ArmarX is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation.
7  *
8  * ArmarX is distributed in the hope that it will be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program. If not, see <http://www.gnu.org/licenses/>.
15  *
16  * @package ROBDEKON::ArmarXObjects::DenseCRFSegmentationProcessor
17  * @author Christoph Pohl ( christoph dot pohl at kit dot edu )
18  * @date 2019
19  * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
20  * GNU General Public License
21  */
22 
23 
24 #ifndef ROBDEKON_DENSECRFFEATURETERMS_H
25 #define ROBDEKON_DENSECRFFEATURETERMS_H
26 
28 #include <pcl/pcl_macros.h>
29 #include "Common.h"
30 
31 namespace armarx
32 {
33 
34 
35  template<class GraphT>
36  struct XYZFeature
37  {
38  typedef typename GraphT::vertex_descriptor VertexId;
39  protected:
40  GraphT& _graph;
41  const long unsigned int _num_features = 3;
42  public:
43  explicit XYZFeature(GraphT& graph) : _graph(graph) {};
44 
45  const Eigen::MatrixXf computeFeatures(std::vector<float> sigma)
46  {
47  ARMARX_CHECK_EXPRESSION(_num_features == sigma.size());
48  const int N = boost::num_vertices(_graph);
49  Eigen::MatrixXf features(_num_features, N);
50  for (VertexId i = 0; i < boost::num_vertices(_graph); i++)
51  {
52  Eigen::Vector3f xyz = _graph[i].getVector3fMap();
53  features(0, i) = xyz[0] / exp(sigma[0]);
54  features(1, i) = xyz[1] / exp(sigma[1]);
55  features(2, i) = xyz[2] / exp(sigma[2]);
56  }
57  return features;
58  }
59  };
60 
61  template<class GraphT>
63  {
64  typedef typename GraphT::vertex_descriptor VertexId;
65  protected:
66  GraphT& _graph;
67  const long unsigned int _num_features = 3;
68  public:
69  explicit NormalFeature(GraphT& graph) : _graph(graph) {};
70 
71  const Eigen::MatrixXf computeFeatures(std::vector<float> sigma)
72  {
73  ARMARX_CHECK_EXPRESSION(_num_features == sigma.size());
74  const int N = boost::num_vertices(_graph);
75  Eigen::MatrixXf features(_num_features, N);
76  for (VertexId i = 0; i < boost::num_vertices(_graph); i++)
77  {
78  Eigen::Vector3f normal = _graph[i].getNormalVector3fMap();
79  features(0, i) = isfinite(normal[0]) ? normal[0] / exp(sigma[0]) : 0;
80  features(1, i) = isfinite(normal[1]) ? normal[1] / exp(sigma[1]) : 0;
81  features(2, i) = isfinite(normal[2]) ? normal[2] / exp(sigma[2]) : 0;
82  }
83  return features;
84  }
85  };
86 
87  template<class GraphT>
89  {
90  typedef typename GraphT::vertex_descriptor VertexId;
91  protected:
92  GraphT& _graph;
93  const long unsigned int _num_features = 1;
94  public:
95  explicit CurvatureFeature(GraphT& graph) : _graph(graph) {};
96 
97  const Eigen::MatrixXf computeFeatures(std::vector<float> sigma)
98  {
99  ARMARX_CHECK_EXPRESSION(_num_features == sigma.size());
100  const int N = boost::num_vertices(_graph);
101  Eigen::MatrixXf features(_num_features, N);
102  for (VertexId i = 0; i < boost::num_vertices(_graph); i++)
103  {
104  float curv = std::fabs(_graph[i].curvature);;
105  features(0, i) = curv / exp(sigma[0]);
106  }
107  return features;
108  }
109  };
110 
111  template<class GraphT>
112  struct RGBFeature
113  {
114  typedef typename GraphT::vertex_descriptor VertexId;
115  protected:
116  GraphT& _graph;
117  const long unsigned int _num_features = 3;
118  public:
119  explicit RGBFeature(GraphT& graph) : _graph(graph) {};
120 
121  const Eigen::MatrixXf computeFeatures(std::vector<float> sigma)
122  {
123  ARMARX_CHECK_EXPRESSION(_num_features == sigma.size());
124  const int N = boost::num_vertices(_graph);
125  Eigen::MatrixXf features(_num_features, N);
126  for (VertexId i = 0; i < boost::num_vertices(_graph); i++)
127  {
128  Eigen::Vector3f rgb = _graph[i].getBGRVector3cMap().template cast<float>() / 255.0f;
129  features(0, i) = rgb[0] / exp(sigma[0]);
130  features(1, i) = rgb[1] / exp(sigma[1]);
131  features(2, i) = rgb[2] / exp(sigma[2]);
132  }
133  return features;
134  }
135  };
136 
137  template<class GraphT>
139  {
140  typedef typename GraphT::vertex_descriptor VertexId;
141  protected:
142  GraphT& _graph;
143  const long unsigned int _num_features = 11;
144  public:
145  explicit CombinedFeature(GraphT& graph) : _graph(graph) {};
146 
147  const Eigen::MatrixXf computeFeatures(std::vector<float> sigma)
148  {
149  ARMARX_CHECK_EXPRESSION(_num_features == sigma.size());
150  const int N = boost::num_vertices(_graph);
151  Eigen::MatrixXf features(_num_features, N);
152  TimestampMap time = boost::get(boost::vertex_timestamp_t(), _graph.m_graph);
153  for (VertexId i = 0; i < boost::num_vertices(_graph); i++)
154  {
155  Eigen::Vector3f rgb = _graph[i].getBGRVector3cMap().template cast<float>() / 255.0f;
156  features(0, i) = rgb[0] / exp(sigma[0]);
157  features(1, i) = rgb[1] / exp(sigma[1]);
158  features(2, i) = rgb[2] / exp(sigma[2]);
159 
160  Eigen::Vector3f normal = _graph[i].getNormalVector3fMap();
161  features(3, i) = std::isfinite(normal[0]) ? normal[0] / exp(sigma[3]) : 0.0;
162  features(4, i) = std::isfinite(normal[1]) ? normal[1] / exp(sigma[4]) : 0.0;
163  features(5, i) = std::isfinite(normal[2]) ? normal[2] / exp(sigma[5]) : 0.0;
164 
165  Eigen::Vector3f xyz = _graph[i].getVector3fMap();
166  features(6, i) = xyz[0] / exp(sigma[6]);
167  features(7, i) = xyz[1] / exp(sigma[7]);
168  features(8, i) = xyz[2] / exp(sigma[8]);
169 
170  // float curv = std::fabs(_graph[i].curvature);
171  float curv = _graph[i].curvature;
172  features(9, i) = std::isfinite(curv) ? curv / exp(sigma[9]) : 0.0;
173 
174  features(10, i) = time[i] / exp(sigma[10]);
175  }
176  return features;
177  }
178  };
179 
180  template<class GraphT>
182  {
183  typedef typename GraphT::vertex_descriptor VertexId;
184  protected:
185  GraphT& _graph;
187  const long unsigned int _num_features = calcNumFeatues();
188  public:
189  explicit VariableCombinedFeature(GraphT& graph, bool useRGB, bool useNormals, bool useXYZ, bool useCurvature,
190  bool useTime) : _graph(graph), useRGB(useRGB), useNorm(useNormals),
191  useXYZ(useXYZ), useCurv(useCurvature), useTime(useTime) {};
192 
193  Eigen::MatrixXf computeFeatures(std::vector<float> sigma)
194  {
195  ARMARX_CHECK_EXPRESSION(_num_features == sigma.size());
196  const int N = boost::num_vertices(_graph);
197  Eigen::MatrixXf features(_num_features, N);
198  TimestampMap time = boost::get(boost::vertex_timestamp_t(), _graph.m_graph);
199  for (VertexId i = 0; i < boost::num_vertices(_graph); i++)
200  {
201  int j = 0;
202  if (useRGB)
203  {
204  Eigen::Vector3f rgb = _graph[i].getBGRVector3cMap().template cast<float>() / 255.0f;
205  features(j, i) = rgb[0] / exp(sigma[j]);
206  features(j + 1, i) = rgb[1] / exp(sigma[j + 1]);
207  features(j + 2, i) = rgb[2] / exp(sigma[j + 2]);
208  j += 3;
209  }
210 
211  if (useNorm)
212  {
213  Eigen::Vector3f normal = _graph[i].getNormalVector3fMap();
214  features(j, i) = std::isfinite(normal[0]) ? normal[0] / exp(sigma[j]) : 0.0;
215  features(j + 1, i) = std::isfinite(normal[1]) ? normal[1] / exp(sigma[j + 1]) : 0.0;
216  features(j + 2, i) = std::isfinite(normal[2]) ? normal[2] / exp(sigma[j + 2]) : 0.0;
217  j += 3;
218  }
219 
220  if (useXYZ)
221  {
222  Eigen::Vector3f xyz = _graph[i].getVector3fMap();
223  features(j, i) = xyz[0] / exp(sigma[j]);
224  features(j + 1, i) = xyz[1] / exp(sigma[j + 1]);
225  features(j + 2, i) = xyz[2] / exp(sigma[j + 2]);
226  j += 3;
227  }
228 
229  if (useCurv)
230  {
231  // float curv = std::fabs(_graph[i].curvature);
232  float curv = _graph[i].curvature;
233  features(j, i) = std::isfinite(curv) ? curv / exp(sigma[j]) : 0.0;
234  j++;
235  }
236 
237  if (useTime)
238  {
239  features(j, i) = time[i] / exp(sigma[j]);
240  }
241 
242 
243  }
244  return features;
245  }
246 
247  private:
248  long unsigned int calcNumFeatues()
249  {
250  long unsigned int _num_feat = 0;
251  _num_feat += useRGB ? 3 : 0;
252  _num_feat += useNorm ? 3 : 0;
253  _num_feat += useXYZ ? 3 : 0;
254  _num_feat += useTime ? 1 : 0;
255  _num_feat += useCurv ? 1 : 0;
256  return _num_feat;
257  }
258  };
259 
260  template<class GraphT>
262  {
263  typedef typename GraphT::vertex_descriptor VertexId;
264  protected:
265  GraphT& _graph;
267  const long unsigned int _num_features = calcNumFeatues();
268  public:
269  explicit VariableCombinedNormalizedFeature(GraphT& graph, bool useRGB, bool useNormals, bool useXYZ,
270  bool useCurvature,
271  bool useTime) : _graph(graph), useRGB(useRGB), useNorm(useNormals),
272  useXYZ(useXYZ), useCurv(useCurvature),
273  useTime(useTime) {};
274 
275  Eigen::MatrixXf computeFeatures(std::vector<float> sigma)
276  {
277  ARMARX_CHECK_EXPRESSION(_num_features == sigma.size());
278  const int N = boost::num_vertices(_graph);
279  Eigen::MatrixXf features(_num_features, N);
280  TimestampMap time = boost::get(boost::vertex_timestamp_t(), _graph.m_graph);
281  Eigen::MatrixXd meanAndStd(_num_features, 2);
282  meanAndStd = calculateMeanAndStd(_graph);
283  ARMARX_DEBUG << "Mean of Input Values: " << meanAndStd.col(0) << "\n Standard Deviation of Input Values: "
284  << meanAndStd.col(1);
285  for (VertexId i = 0; i < boost::num_vertices(_graph); i++)
286  {
287  int j = -1;
288  if (useRGB)
289  {
290  Eigen::Vector3f rgb = _graph[i].getBGRVector3cMap().template cast<float>() / 255.0f;
291  ++j;
292  features(j, i) = ((rgb[0] - meanAndStd(j, 0)) / meanAndStd(j, 1)) / exp(sigma[j]);
293  ++j;
294  features(j, i) = ((rgb[1] - meanAndStd(j, 0)) / meanAndStd(j, 1)) / exp(sigma[j]);
295  ++j;
296  features(j, i) = ((rgb[2] - meanAndStd(j, 0)) / meanAndStd(j, 1)) / exp(sigma[j]);
297  }
298 
299  if (useNorm)
300  {
301  Eigen::Vector3f normal = _graph[i].getNormalVector3fMap();
302  ++j;
303  features(j, i) = std::isfinite(normal[0]) ? ((normal[0] - meanAndStd(j, 0)) / meanAndStd(j, 1)) /
304  exp(sigma[j]) : 0.0;
305  ++j;
306  features(j, i) = std::isfinite(normal[1]) ? ((normal[1] - meanAndStd(j, 0)) / meanAndStd(j, 1)) /
307  exp(sigma[j]) : 0.0;
308  ++j;
309  features(j, i) = std::isfinite(normal[2]) ? ((normal[2] - meanAndStd(j, 0)) / meanAndStd(j, 1)) /
310  exp(sigma[j]) : 0.0;
311  }
312 
313  if (useXYZ)
314  {
315  Eigen::Vector3f xyz = _graph[i].getVector3fMap();
316  ++j;
317  features(j, i) = ((xyz[0] - meanAndStd(j, 0)) / meanAndStd(j, 1)) / exp(sigma[j]);
318  ++j;
319  features(j, i) = ((xyz[1] - meanAndStd(j, 0)) / meanAndStd(j, 1)) / exp(sigma[j]);
320  ++j;
321  features(j, i) = ((xyz[2] - meanAndStd(j, 0)) / meanAndStd(j, 1)) / exp(sigma[j]);
322  }
323 
324  if (useCurv)
325  {
326  // float curv = std::fabs(_graph[i].curvature);
327  float curv = _graph[i].curvature;
328  ++j;
329  features(j, i) = std::isfinite(curv) ? ((curv - meanAndStd(j, 0)) / meanAndStd(j, 1)) /
330  exp(sigma[j]) : 0.0;
331  }
332 
333  if (useTime)
334  {
335  ++j;
336  features(j, i) = ((time[i] - meanAndStd(j, 0)) / meanAndStd(j, 1)) / exp(sigma[j]);
337  }
338 
339 
340  }
341  return features;
342  }
343 
344  private:
345 
346  Eigen::MatrixXd calculateMeanAndStd(GraphT& graph)
347  {
348  // this uses Welford's algorithm
349  // k = 0
350  // M = 0
351  // S = 0
352  // for x in x_array:
353  // k += 1
354  // Mnext = M + (x - M) / k
355  // S = S + (x - M)*(x - Mnext)
356  // M = Mnext
357  // return (M, S/(k-1))
358  Eigen::MatrixXd meanAndStd(_num_features, 2);
359  meanAndStd.setZero();
360  TimestampMap time = boost::get(boost::vertex_timestamp_t(), _graph.m_graph);
361  int k = 0;
362  for (VertexId i = 0; i < boost::num_vertices(_graph); i++)
363  {
364  // TODO: k might not be needed
365  k++;
366  Eigen::VectorXd x(_num_features);
367 
368  int j = 0;
369  if (useRGB)
370  {
371  Eigen::Vector3f rgb = _graph[i].getBGRVector3cMap().template cast<float>() / 255.0f;
372  x(j) = rgb[0];
373  x(j + 1) = rgb[1];
374  x(j + 2) = rgb[2];
375  j += 3;
376  }
377 
378  if (useNorm)
379  {
380  Eigen::Vector3f normal = _graph[i].getNormalVector3fMap();
381  x(j) = std::isfinite(normal[0]) ? normal[0] : 0.0;
382  x(j + 1) = std::isfinite(normal[1]) ? normal[1] : 0.0;
383  x(j + 2) = std::isfinite(normal[2]) ? normal[2] : 0.0;
384  j += 3;
385  }
386 
387  if (useXYZ)
388  {
389  Eigen::Vector3f xyz = _graph[i].getVector3fMap();
390  x(j) = xyz[0];
391  x(j + 1) = xyz[1];
392  x(j + 2) = xyz[2];
393  j += 3;
394  }
395 
396  if (useCurv)
397  {
398  // float curv = std::fabs(_graph[i].curvature);
399  float curv = _graph[i].curvature;
400  x(j) = std::isfinite(curv) ? curv : 0.0;
401  j++;
402  }
403 
404  if (useTime)
405  {
406  x(j) = time[i];
407  }
408  Eigen::VectorXd meanNext = meanAndStd.col(0) + (x - meanAndStd.col(0)) / double(k);
409  meanAndStd.col(1) += (x - meanAndStd.col(0)).cwiseProduct(x - meanNext);
410  meanAndStd.col(0) = meanNext;
411 
412  }
413  // for the first image, all the timestamps are the same, resulting in variance of 0 --> breaks things
414  meanAndStd.col(1) = (meanAndStd.col(1) / double(k - 1)).cwiseSqrt().array() + 1e-8;
415  return meanAndStd;
416  }
417 
418  long unsigned int calcNumFeatues()
419  {
420  long unsigned int _num_feat = 0;
421  _num_feat += useRGB ? 3 : 0;
422  _num_feat += useNorm ? 3 : 0;
423  _num_feat += useXYZ ? 3 : 0;
424  _num_feat += useTime ? 1 : 0;
425  _num_feat += useCurv ? 1 : 0;
426  return _num_feat;
427  }
428  };
429 
430  struct TimeFeature
431  {
432  typedef typename GraphWithTimestamp::vertex_descriptor VertexId;
433  protected:
435  const long unsigned int _num_features = 1;
436  public:
437  explicit TimeFeature(GraphWithTimestamp& graph) : _graph(graph) {};
438 
439  const Eigen::MatrixXf computeFeatures(std::vector<float> sigma)
440  {
441  ARMARX_CHECK_EXPRESSION(_num_features == sigma.size());
442  const int N = boost::num_vertices(_graph);
443  Eigen::MatrixXf features(_num_features, N);
444  TimestampMap time = boost::get(boost::vertex_timestamp_t(), _graph.m_graph);
445  for (VertexId i = 0; i < boost::num_vertices(_graph); i++)
446  {
447  features(0, i) = (time[i]) / exp(sigma[0]);
448  }
449  return features;
450  }
451  };
452 }
453 #endif //ROBDEKON_DENSECRFFEATURETERMS_H
armarx::TimeFeature::TimeFeature
TimeFeature(GraphWithTimestamp &graph)
Definition: DenseCRFFeatureTerms.h:437
armarx::XYZFeature::_graph
GraphT & _graph
Definition: DenseCRFFeatureTerms.h:40
armarx::VariableCombinedNormalizedFeature::VariableCombinedNormalizedFeature
VariableCombinedNormalizedFeature(GraphT &graph, bool useRGB, bool useNormals, bool useXYZ, bool useCurvature, bool useTime)
Definition: DenseCRFFeatureTerms.h:269
armarx::TimeFeature
Definition: DenseCRFFeatureTerms.h:430
boost::vertex_timestamp_t
Definition: Common.h:15
armarx::CurvatureFeature
Definition: DenseCRFFeatureTerms.h:88
armarx::CombinedFeature::_num_features
const long unsigned int _num_features
Definition: DenseCRFFeatureTerms.h:143
armarx::TimeFeature::computeFeatures
const Eigen::MatrixXf computeFeatures(std::vector< float > sigma)
Definition: DenseCRFFeatureTerms.h:439
armarx::NormalFeature
Definition: DenseCRFFeatureTerms.h:62
armarx::VariableCombinedNormalizedFeature
Definition: DenseCRFFeatureTerms.h:261
armarx::VariableCombinedNormalizedFeature::_graph
GraphT & _graph
Definition: DenseCRFFeatureTerms.h:265
armarx::VariableCombinedFeature::VariableCombinedFeature
VariableCombinedFeature(GraphT &graph, bool useRGB, bool useNormals, bool useXYZ, bool useCurvature, bool useTime)
Definition: DenseCRFFeatureTerms.h:189
armarx::NormalFeature::_num_features
const long unsigned int _num_features
Definition: DenseCRFFeatureTerms.h:67
armarx::XYZFeature::XYZFeature
XYZFeature(GraphT &graph)
Definition: DenseCRFFeatureTerms.h:43
armarx::RGBFeature::computeFeatures
const Eigen::MatrixXf computeFeatures(std::vector< float > sigma)
Definition: DenseCRFFeatureTerms.h:121
armarx::VariableCombinedFeature::useNorm
bool useNorm
Definition: DenseCRFFeatureTerms.h:186
Common.h
armarx::VariableCombinedFeature::useRGB
bool useRGB
Definition: DenseCRFFeatureTerms.h:186
armarx::NormalFeature::_graph
GraphT & _graph
Definition: DenseCRFFeatureTerms.h:66
armarx::VariableCombinedNormalizedFeature::computeFeatures
Eigen::MatrixXf computeFeatures(std::vector< float > sigma)
Definition: DenseCRFFeatureTerms.h:275
armarx::VertexId
boost::graph_traits< Graph >::vertex_descriptor VertexId
Definition: Common.h:64
armarx::VariableCombinedNormalizedFeature::_num_features
const long unsigned int _num_features
Definition: DenseCRFFeatureTerms.h:267
armarx::XYZFeature::_num_features
const long unsigned int _num_features
Definition: DenseCRFFeatureTerms.h:41
armarx::CombinedFeature::VertexId
GraphT::vertex_descriptor VertexId
Definition: DenseCRFFeatureTerms.h:140
armarx::CurvatureFeature::_graph
GraphT & _graph
Definition: DenseCRFFeatureTerms.h:92
armarx::TimeFeature::_num_features
const long unsigned int _num_features
Definition: DenseCRFFeatureTerms.h:435
armarx::NormalFeature::NormalFeature
NormalFeature(GraphT &graph)
Definition: DenseCRFFeatureTerms.h:69
armarx::VariableCombinedNormalizedFeature::VertexId
GraphT::vertex_descriptor VertexId
Definition: DenseCRFFeatureTerms.h:263
armarx::RGBFeature::VertexId
GraphT::vertex_descriptor VertexId
Definition: DenseCRFFeatureTerms.h:114
armarx::VariableCombinedNormalizedFeature::useTime
bool useTime
Definition: DenseCRFFeatureTerms.h:266
armarx::XYZFeature
Definition: DenseCRFFeatureTerms.h:36
std::isfinite
bool isfinite(const std::vector< T, Ts... > &v)
Definition: algorithm.h:327
armarx::NormalFeature::computeFeatures
const Eigen::MatrixXf computeFeatures(std::vector< float > sigma)
Definition: DenseCRFFeatureTerms.h:71
armarx::CurvatureFeature::_num_features
const long unsigned int _num_features
Definition: DenseCRFFeatureTerms.h:93
armarx::VariableCombinedFeature::useTime
bool useTime
Definition: DenseCRFFeatureTerms.h:186
armarx::TimeFeature::VertexId
GraphWithTimestamp::vertex_descriptor VertexId
Definition: DenseCRFFeatureTerms.h:432
armarx::TimeFeature::_graph
GraphWithTimestamp & _graph
Definition: DenseCRFFeatureTerms.h:434
armarx::VariableCombinedFeature::_graph
GraphT & _graph
Definition: DenseCRFFeatureTerms.h:185
ARMARX_DEBUG
#define ARMARX_DEBUG
Definition: Logging.h:177
armarx::VariableCombinedFeature::computeFeatures
Eigen::MatrixXf computeFeatures(std::vector< float > sigma)
Definition: DenseCRFFeatureTerms.h:193
armarx::RGBFeature
Definition: DenseCRFFeatureTerms.h:112
armarx::CombinedFeature::computeFeatures
const Eigen::MatrixXf computeFeatures(std::vector< float > sigma)
Definition: DenseCRFFeatureTerms.h:147
armarx::CombinedFeature::_graph
GraphT & _graph
Definition: DenseCRFFeatureTerms.h:142
armarx::TimestampMap
boost::property_map< CloudGraphWithTimestamp, boost::vertex_timestamp_t >::type TimestampMap
Definition: Common.h:70
armarx::RGBFeature::_graph
GraphT & _graph
Definition: DenseCRFFeatureTerms.h:116
armarx::VariableCombinedNormalizedFeature::useXYZ
bool useXYZ
Definition: DenseCRFFeatureTerms.h:266
armarx::VariableCombinedFeature::useCurv
bool useCurv
Definition: DenseCRFFeatureTerms.h:186
armarx::VariableCombinedNormalizedFeature::useCurv
bool useCurv
Definition: DenseCRFFeatureTerms.h:266
armarx::VariableCombinedFeature::_num_features
const long unsigned int _num_features
Definition: DenseCRFFeatureTerms.h:187
ExpressionException.h
armarx::VariableCombinedFeature::useXYZ
bool useXYZ
Definition: DenseCRFFeatureTerms.h:186
armarx::RGBFeature::_num_features
const long unsigned int _num_features
Definition: DenseCRFFeatureTerms.h:117
armarx::CurvatureFeature::computeFeatures
const Eigen::MatrixXf computeFeatures(std::vector< float > sigma)
Definition: DenseCRFFeatureTerms.h:97
ARMARX_CHECK_EXPRESSION
#define ARMARX_CHECK_EXPRESSION(expression)
This macro evaluates the expression and if it turns out to be false it will throw an ExpressionExcept...
Definition: ExpressionException.h:73
armarx::CurvatureFeature::CurvatureFeature
CurvatureFeature(GraphT &graph)
Definition: DenseCRFFeatureTerms.h:95
armarx::XYZFeature::computeFeatures
const Eigen::MatrixXf computeFeatures(std::vector< float > sigma)
Definition: DenseCRFFeatureTerms.h:45
armarx::NormalFeature::VertexId
GraphT::vertex_descriptor VertexId
Definition: DenseCRFFeatureTerms.h:64
armarx::CurvatureFeature::VertexId
GraphT::vertex_descriptor VertexId
Definition: DenseCRFFeatureTerms.h:90
armarx::VariableCombinedFeature
Definition: DenseCRFFeatureTerms.h:181
armarx::VariableCombinedNormalizedFeature::useNorm
bool useNorm
Definition: DenseCRFFeatureTerms.h:266
armarx::VariableCombinedFeature::VertexId
GraphT::vertex_descriptor VertexId
Definition: DenseCRFFeatureTerms.h:183
armarx::VariableCombinedNormalizedFeature::useRGB
bool useRGB
Definition: DenseCRFFeatureTerms.h:266
armarx::CombinedFeature::CombinedFeature
CombinedFeature(GraphT &graph)
Definition: DenseCRFFeatureTerms.h:145
armarx::RGBFeature::RGBFeature
RGBFeature(GraphT &graph)
Definition: DenseCRFFeatureTerms.h:119
armarx::GraphWithTimestamp
boost::subgraph< CloudGraphWithTimestamp > GraphWithTimestamp
Definition: Common.h:55
armarx
This file offers overloads of toIce() and fromIce() functions for STL container types.
Definition: ArmarXTimeserver.cpp:28
armarx::CombinedFeature
Definition: DenseCRFFeatureTerms.h:138
armarx::XYZFeature::VertexId
GraphT::vertex_descriptor VertexId
Definition: DenseCRFFeatureTerms.h:38