PointCloudSegmenter.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of ArmarX.
3  *
4  * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
5  *
6  * ArmarX is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * ArmarX is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  *
18  * @package VisionX
19  * @author Eren Aksoy ( eren dot aksoy at kit dot edu )
20  * @date 2015
21  * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
22  * GNU General Public License
23  */
24 
25 #include "PointCloudSegmenter.h"
26 
29 
31 
33 
34 #include <pcl/common/colors.h>
35 #include <pcl/filters/crop_box.h>
36 
37 #include <QSettings>
38 
39 using namespace armarx;
40 namespace visionx
41 {
42  PointCloudSegmenter::PointCloudSegmenter() :
43  inputCloudPtr(new pcl::PointCloud<PointO>),
44  labeledColoredCloudPtr(new pcl::PointCloud<PointRGBL>)
45  {
46  }
47 
49  {
50  lastProcessedTimestamp = 0;
51 
52  // Get point cloud provider name
53  providerName = getProperty<std::string>("ProviderName").getValue();
54  ARMARX_INFO << "Using point cloud provider " << providerName << flush;
55 
56 
57  // Get segmentation method
58  segmentationMethod = getProperty<std::string>("segmentationMethod").getValue();
59  ARMARX_INFO << "Using the segmentation method " << segmentationMethod << flush;
60 
61  offeringTopic(getProperty<std::string>("DebugDrawerTopicName").getValue());
62 
63  enabled = getProperty<bool>("StartEnabled").getValue();
64  ARMARX_INFO << "Starting " << (enabled ? "Enabled" : "Disabled");
65 
66  // get LCCP segmentation parameters
67  minSegSize = getProperty<int>("lccpMinimumSegmentSize").getValue();
68  voxelRes = getProperty<float>("lccpVoxelResolution").getValue();
69  seedRes = getProperty<float>("lccpSeedResolution").getValue();
70  colorImp = getProperty<float>("lccpColorImportance").getValue();
71  spatialImp = getProperty<float>("lccpSpatialImportance").getValue();
72  normalImp = getProperty<float>("lccpNormalImportance").getValue();
73  concavityThres = getProperty<float>("lccpConcavityThreshold").getValue();
74  smoothnessThes = getProperty<float>("lccpSmoothnessThreshold").getValue();
75 
76  // get RG segmentation parameters
77  rgSmoothnessThes = getProperty<float>("rgSmoothnessThreshold").getValue();
78  rgCurvatureThres = getProperty<float>("rgCurvatureThreshold").getValue();
79 
80  // init segmenters and update parameters
81  if (segmentationMethod == "LCCP")
82  {
83  pLCCP = new LCCPSegClass();
84  pLCCP->UpdateParameters(voxelRes, seedRes, colorImp, spatialImp, normalImp, concavityThres, smoothnessThes, minSegSize);
85  }
86  else if (segmentationMethod == "RG")
87  {
88  pRGSegmenter = new RGSegClass();
89  pRGSegmenter->UpdateRegionGrowingSegmentationParameters(rgSmoothnessThes, rgCurvatureThres);
90  }
91  else if (segmentationMethod == "EC")
92  {
93  pECSegmenter = new EuclideanBasedClustering();
94  }
95  else if (segmentationMethod == "DS")
96  {
97  usingProxy(getProperty<std::string>("DeepSegmenterTopicName").getValue());
98  pDeepSegmenter = new DeepSegClass();
99  }
100  }
101 
103  {
104  debugDrawerTopic = getTopic<armarx::DebugDrawerInterfacePrx>(getProperty<std::string>("DebugDrawerTopicName").getValue());
105  if (!debugDrawerTopic)
106  {
107  ARMARX_WARNING << "Failed to obtain debug drawer proxy";
108  }
109 
110  if (segmentationMethod == "DS")
111  {
112  deepSegmenterTopic = getProxy<armarx::DeepSegmenterInterfacePrx>(getProperty<std::string>("DeepSegmenterTopicName").getValue());
113  if (!deepSegmenterTopic)
114  {
115  ARMARX_WARNING << "Failed to obtain deep segmenter proxy";
116  }
117  }
118 
119  enableResultPointClouds<PointRGBL>();
120 
123  }
124 
126  {
127  }
128 
130  {
131  if (pLCCP)
132  {
133  delete pLCCP;
134  }
135 
136  if (pRGSegmenter)
137  {
138  delete pRGSegmenter;
139  }
140 
141  if (pECSegmenter)
142  {
143  delete pECSegmenter;
144  }
145 
146  if (pDeepSegmenter)
147  {
148  delete pDeepSegmenter;
149  }
150  }
151 
153  {
154  {
155  std::unique_lock lock(enableMutex);
156 
157  if (!enabled)
158  {
159  return;
160  }
161  }
162 
163  if (!waitForPointClouds(providerName, 10000))
164  {
165  ARMARX_WARNING << "Timeout or error while waiting for point cloud data" << armarx::flush;
166  return;
167  }
168 
169 
170  //if (getPointCloudFormat(providerName)->type == eColoredLabeledPoints)
171  //{
172  // ARMARX_INFO << "Received RGBL point cloud: Passing on already segmented point cloud";
173  //
174  // labeledColoredCloudPtr.reset(new pcl::PointCloud<pcl::PointXYZRGBL>());
175  // getPointClouds(providerName, labeledColoredCloudPtr);
176  // provideResultPointClouds(labeledColoredCloudPtr);
177  //
178  // {
179  // std::unique_lock lock(timestampMutex);
180  // lastProcessedTimestamp = getPointCloudFormat(providerName)->timeProvided;
181  // }
182  //
183  // return;
184  //}
185  //else
186  //{
187  getPointClouds(providerName, inputCloudPtr);
188  ARMARX_INFO << "Point cloud received (size: " << inputCloudPtr->points.size() << ", providerName: " << providerName << ")";
189  //}
190 
191  MetaPointCloudFormatPtr info = getPointCloudFormat(providerName);
192  IceUtil::Int64 originalTimestamp = info->timeProvided;
193 
194  IceUtil::Time ts = IceUtil::Time::microSeconds(originalTimestamp);
195  std::string timestampString = ts.toDateTime().substr(ts.toDateTime().find(' ') + 1);
196 
197  IceUtil::Time start_ts = IceUtil::Time::now();
198 
199  ARMARX_INFO << "Point cloud received (timestamp: " << timestampString << ", size: " << inputCloudPtr->points.size() << ", providerName: " << providerName << ")";
200  if (inputCloudPtr->points.size() == 0)
201  {
202  return;
203  }
204 
205  if (segmentationMethod == "LCCP")
206  {
207  pcl::PointCloud< pcl::PointXYZL >::Ptr labeledPCPtr = pLCCP->GetLabeledPointCloud(inputCloudPtr);
208  labeledColoredCloudPtr.reset(new pcl::PointCloud<PointRGBL>()); // returns labeled cloud in XYZL format
209 
210  if (inputCloudPtr->size() != labeledPCPtr->size())
211  {
212  ARMARX_WARNING << "Point cloud size mismatch (RGB: " << inputCloudPtr->size() << ", XYZL: " << labeledPCPtr->size() << "), skipping current frame";
213  return;
214  }
215 
216 
217  pcl::concatenateFields(*inputCloudPtr, *labeledPCPtr, *labeledColoredCloudPtr);
218  ARMARX_INFO << " computed supervoxelcluster size: " << pLCCP->GetSuperVoxelClusterSize() ;
219  ARMARX_INFO << " computed labeledCloudPtr size: " << labeledColoredCloudPtr->points.size() ;
220  }
221  else if (segmentationMethod == "RG")
222  {
223  pRGSegmenter->UpdateRegionGrowingSegmentationParameters(rgSmoothnessThes, rgCurvatureThres);
224  auto colorizedLabeledCloudPtr = pRGSegmenter->ApplyRegionGrowingSegmentation(inputCloudPtr); // returns labeled cloud in XYZRGBA format
225  pcl::PointCloud< pcl::PointXYZL >::Ptr labeledPCPtr(new pcl::PointCloud< pcl::PointXYZL >());
226  convertFromXYZRGBAtoXYZL(colorizedLabeledCloudPtr, labeledPCPtr); // convert form XYZRGBA to XYZL for the labeling process
227  labeledColoredCloudPtr.reset(new pcl::PointCloud<PointRGBL>());
228  pcl::concatenateFields(*inputCloudPtr, *labeledPCPtr, *labeledColoredCloudPtr);
229  }
230  else if (segmentationMethod == "EC")
231  {
232  labeledColoredCloudPtr = pECSegmenter->GetLabeledPointCloud(inputCloudPtr);
233  }
234  else if (segmentationMethod == "DS")
235  {
236  if (!deepSegmenterTopic) // check the proxy
237  {
238  ARMARX_WARNING << "Failed to obtain deep segmenter proxy";
239  return;
240  }
241 
242  if (!inputCloudPtr->isOrganized()) // the input cloud must be organized
243  {
244  ARMARX_WARNING << "Input point cloud is not organized!";
245  return;
246  }
247 
248  // first get rgb image from the point cloud data
249  rgbImage = pDeepSegmenter->GetImageFromPointCloud(inputCloudPtr);
250 
251  deepSegmenterTopic->setImageDimensions(inputCloudPtr->width, inputCloudPtr->height);
252  armarx::Blob deepSegmentImage = deepSegmenterTopic->segmentImage(rgbImage);
253 
254  labeledColoredCloudPtr = pDeepSegmenter->GetLabeledPointCloud(inputCloudPtr, deepSegmentImage);
255 
256  }
257 
258  // Provide point cloud referencing the time stamp of the original source point cloud
259  labeledColoredCloudPtr->header.stamp = originalTimestamp;
260 
261  {
262  std::unique_lock lock(enableMutex);
263 
264  // Do not provide result if segmenter has been switched off in the meantime
265  if (enabled)
266  {
267  provideResultPointClouds(labeledColoredCloudPtr);
268 
269  {
270  std::unique_lock lock(timestampMutex);
271  lastProcessedTimestamp = originalTimestamp;
272  }
273  }
274  }
275 
276  ARMARX_INFO << "Point cloud segmentation took " << (IceUtil::Time::now() - start_ts).toSecondsDouble() << " secs";
277 
278  if (getProperty<bool>("SingleRun").getValue())
279  {
280  ARMARX_WARNING << "PointCloudSegmenter configured to run only once";
281  enabled = false;
282  }
283  }
284 
286  {
288  }
289 
290  void PointCloudSegmenter::enablePipelineStep(const Ice::Current& c)
291  {
292  std::unique_lock lock(enableMutex);
293  enabled = true;
294 
295  ARMARX_INFO << "Enabling segmentation";
296  }
297 
298  void PointCloudSegmenter::disablePipelineStep(const Ice::Current& c)
299  {
300  std::unique_lock lock(enableMutex);
301  enabled = false;
302 
303  ARMARX_INFO << "Disabling segmentation";
304  }
305 
306  void PointCloudSegmenter::changePointCloudProvider(const std::string& providerName, const Ice::Current& c)
307  {
308  std::unique_lock lock(providerMutex);
309 
310  ARMARX_INFO << "Changing point cloud provider to '" << providerName << "'";
311 
313 
314  releasePointCloudProvider(this->providerName);
315  this->providerName = providerName;
316  usingPointCloudProvider(this->providerName);
317 
319  }
320 
321  void PointCloudSegmenter::convertFromXYZRGBAtoXYZL(pcl::PointCloud<pcl::PointXYZRGBA>::Ptr& sourceCloudPtr, pcl::PointCloud<pcl::PointXYZL>::Ptr& targetCloudPtr)
322  {
323  targetCloudPtr->resize(sourceCloudPtr->points.size());
324  uint32_t newLabel = 1;
325 
326  struct rgbValues
327  {
328  int rVal;
329  int gVal;
330  int bVal;
331  };
332  std::map<uint32_t, rgbValues > colorMap;
333 
334  // scan the source cloud
335  for (size_t i = 0; i < sourceCloudPtr->points.size(); i++)
336  {
337  rgbValues currRGB;
338  currRGB.rVal = (int) sourceCloudPtr->points[i].r;
339  currRGB.gVal = (int) sourceCloudPtr->points[i].g;
340  currRGB.bVal = (int) sourceCloudPtr->points[i].b;
341 
342  bool isFound = false;
343  uint32_t foundLabel = 0;
344 
345  // search in the map
346  std::map<uint32_t, rgbValues >::iterator iter_i;
347 
348  for (iter_i = colorMap.begin(); iter_i != colorMap.end(); iter_i++)
349  {
350  if (currRGB.rVal == iter_i->second.rVal && currRGB.gVal == iter_i->second.gVal && currRGB.bVal == iter_i->second.bVal)
351  {
352  foundLabel = iter_i->first;
353  isFound = true;
354  break;
355  }
356  }
357 
358  if (!isFound)
359  {
360  colorMap[newLabel] = currRGB;
361  foundLabel = newLabel;
362  newLabel++;
363  }
364 
365  targetCloudPtr->points[i].x = sourceCloudPtr->points[i].x;
366  targetCloudPtr->points[i].y = sourceCloudPtr->points[i].y;
367  targetCloudPtr->points[i].z = sourceCloudPtr->points[i].z;
368  targetCloudPtr->points[i].label = foundLabel;
369  }
370  }
371 
373  {
374  std::unique_lock lock(enableMutex);
375  return enabled;
376  }
377 
378  armarx::TimestampBasePtr visionx::PointCloudSegmenter::getLastProcessedTimestamp(const Ice::Current& c)
379  {
380  std::unique_lock lock(timestampMutex);
381  return new TimestampVariant(lastProcessedTimestamp);
382  }
383 
384  void PointCloudSegmenter::setLccpParameters(const LccpParameters& parameters, const Ice::Current& c)
385  {
386  ARMARX_INFO << "Updating LCCP parameter setup (current segmentation method is " << segmentationMethod << ")";
387  pLCCP->UpdateParameters(parameters.voxelResolution, parameters.seedResolution, parameters.colorImportance,
388  parameters.spatialImportance, parameters.normalImportance, parameters.concavityThreshold,
389  parameters.smoothnessThreshold, parameters.minSegmentSize);
390  }
391 
392  void PointCloudSegmenter::loadLccpParametersFromFile(const std::string& filename, const Ice::Current& c)
393  {
394  std::string absolute_filename;
395  ArmarXDataPath::getAbsolutePath(filename, absolute_filename);
396 
397  ARMARX_INFO << "Loading LCCP parameter setup from " << absolute_filename;
398  QSettings config(QString::fromStdString(absolute_filename), QSettings::IniFormat);
399 
400  config.beginGroup("LCCP");
401  pLCCP->UpdateParameters(
402  config.value("VoxelResolution", getProperty<float>("lccpVoxelResolution").getValue()).toFloat(),
403  config.value("SeedResolution", getProperty<float>("lccpSeedResolution").getValue()).toFloat(),
404  config.value("ColorImportance", getProperty<float>("lccpColorImportance").getValue()).toFloat(),
405  config.value("SpatialImportance", getProperty<float>("lccpSpatialImportance").getValue()).toFloat(),
406  config.value("NormalImportance", getProperty<float>("lccpNormalImportance").getValue()).toFloat(),
407  config.value("ConcavityThreshold", getProperty<float>("lccpConcavityThreshold").getValue()).toFloat(),
408  config.value("SmoothnessThreshold", getProperty<float>("lccpSmoothnessThreshold").getValue()).toFloat(),
409  config.value("MinSegmentSize", getProperty<int>("lccpMinimumSegmentSize").getValue()).toInt()
410  );
411  config.endGroup();
412  }
413 
414 
415  LccpParameters PointCloudSegmenter::getLccpParameters(const Ice::Current& c)
416  {
417  LccpParameters parameters;
418 
419  parameters.voxelResolution = pLCCP->voxel_resolution;
420  parameters.seedResolution = pLCCP->seed_resolution;
421  parameters.colorImportance = pLCCP->color_importance;
422  parameters.spatialImportance = pLCCP->spatial_importance;
423  parameters.normalImportance = pLCCP->normal_importance;
424  parameters.concavityThreshold = pLCCP->concavity_tolerance_threshold;
425  parameters.smoothnessThreshold = pLCCP->smoothness_threshold;
426  parameters.minSegmentSize = pLCCP->min_segment_size;
427 
428 
429  return parameters;
430  }
431 
432  void PointCloudSegmenter::setRgParameters(float smoothnessThreshold, float curvatureThreshold, const Ice::Current& c)
433  {
434  ARMARX_INFO << "Updating RG parameter setup";
435  pRGSegmenter->UpdateRegionGrowingSegmentationParameters(smoothnessThreshold, curvatureThreshold);
436  }
437 
438  void PointCloudSegmenter::loadRgParametersFromFile(const std::string& filename, const Ice::Current& c)
439  {
440  std::string absolute_filename;
441  ArmarXDataPath::getAbsolutePath(filename, absolute_filename);
442 
443  ARMARX_INFO << "Loading RG parameter setup from " << absolute_filename;
444  QSettings config(QString::fromStdString(absolute_filename), QSettings::IniFormat);
445 
446  config.beginGroup("RG");
448  config.value("SmoothnessThreshold", getProperty<double>("rgSmoothnessThreshold").getValue()).toDouble(),
449  config.value("CurvatureThreshold", getProperty<double>("rgCurvatureThreshold").getValue()).toDouble()
450  );
451  config.endGroup();
452  }
453 
455  {
456  GridLayout grid;
457  int row = 0;
458  {
459  tab.rgSmoothnessThreshold.setRange(1.0, 20.0);
461  tab.rgSmoothnessThreshold.setValue(rgSmoothnessThes);
463  grid.add(Label("rgSmoothnessThreshold:"), Pos{row, 0});
464  grid.add(tab.rgSmoothnessThreshold, Pos{row, 1});
465  row += 1;
466  }
467  {
468  tab.rgCurvatureThreshold.setRange(1.0, 50.0);
470  tab.rgCurvatureThreshold.setValue(rgCurvatureThres);
472  grid.add(Label("rgCurvatureThreshold:"), Pos{row, 0});
473  grid.add(tab.rgCurvatureThreshold, Pos{row, 1});
474  row += 1;
475  }
476 
477  RemoteGui_createTab("PointCloudSegmenter", grid, &tab);
478  }
479 
481  {
482  rgSmoothnessThes = tab.rgSmoothnessThreshold.getValue();
483  rgCurvatureThres = tab.rgCurvatureThreshold.getValue();
484  }
485 
486 }
pcl
Definition: pcl_point_operators.cpp:4
armarx::RemoteGui::Client::FloatSpinBox::getValue
float getValue() const
Definition: Widgets.cpp:332
visionx::PointCloudSegmenter::onConnectPointCloudProcessor
void onConnectPointCloudProcessor() override
Definition: PointCloudSegmenter.cpp:102
visionx::PointCloudSegmenter::getLccpParameters
LccpParameters getLccpParameters(const Ice::Current &c=Ice::emptyCurrent) override
Definition: PointCloudSegmenter.cpp:415
EuclideanBasedClustering
Definition: EuclideanBasedClustering.h:44
visionx::PointCloudProcessor::getPointCloudFormat
MetaPointCloudFormatPtr getPointCloudFormat(std::string providerName)
Definition: PointCloudProcessor.cpp:506
visionx
ArmarX headers.
Definition: OpenPoseStressTest.h:38
visionx::PointCloudSegmenterPropertyDefinitions
Definition: PointCloudSegmenter.h:81
visionx::PointCloudSegmenter::changePointCloudProvider
void changePointCloudProvider(const std::string &providerName, const Ice::Current &c=Ice::emptyCurrent) override
Definition: PointCloudSegmenter.cpp:306
visionx::PointCloudSegmenter::createRemoteGuiTab
void createRemoteGuiTab()
Definition: PointCloudSegmenter.cpp:454
Pose.h
armarx::RemoteGui::Client::GridLayout::add
GridLayout & add(Widget const &child, Pos pos, Span span=Span{1, 1})
Definition: Widgets.cpp:412
DeepSegClass::GetImageFromPointCloud
armarx::Blob GetImageFromPointCloud(pcl::PointCloud< pcl::PointXYZRGBA >::Ptr &CloudPtr)
Definition: Deep_Segmenter.cpp:60
armarx::RemoteGui::Client::FloatSpinBox::setValue
void setValue(float newValue)
Definition: Widgets.cpp:337
armarx::TimestampVariant
Definition: TimestampVariant.h:54
visionx::PointCloudProcessor::onDisconnectComponent
virtual void onDisconnectComponent() override
Definition: PointCloudProcessor.cpp:217
armarx::RemoteGui::Client::FloatSpinBox::setRange
void setRange(float min, float max)
Definition: Widgets.cpp:313
c
constexpr T c
Definition: UnscentedKalmanFilterTest.cpp:43
visionx::PointRGBL
pcl::PointXYZRGBL PointRGBL
Definition: PointCloudSegmenter.h:67
RGSegClass
Definition: RG_Segmenter.h:38
visionx::PointCloudSegmenterTab::rgSmoothnessThreshold
FloatSpinBox rgSmoothnessThreshold
Definition: PointCloudSegmenter.h:73
visionx::PointCloudSegmenter::createPropertyDefinitions
armarx::PropertyDefinitionsPtr createPropertyDefinitions() override
Definition: PointCloudSegmenter.cpp:285
visionx::voxelgrid::Label
uint32_t Label
Type of an object label.
Definition: types.h:7
armarx::RemoteGui::Client::GridLayout
Definition: Widgets.h:186
EuclideanBasedClustering::GetLabeledPointCloud
pcl::PointCloud< pcl::PointXYZRGBL >::Ptr & GetLabeledPointCloud(pcl::PointCloud< PointO >::Ptr &CloudPtr)
Definition: EuclideanBasedClustering.cpp:34
armarx::RemoteGui::Client::Pos
Definition: Widgets.h:174
visionx::PointCloudSegmenter::onDisconnectPointCloudProcessor
void onDisconnectPointCloudProcessor() override
Definition: PointCloudSegmenter.cpp:125
visionx::PointCloudProcessor::provideResultPointClouds
void provideResultPointClouds(const PointCloudPtrT &pointClouds, std::string providerName="")
sends result PointClouds for visualization
Definition: PointCloudProcessor.h:286
RGSegClass::ApplyRegionGrowingSegmentation
pcl::PointCloud< pcl::PointXYZRGBA >::Ptr & ApplyRegionGrowingSegmentation(pcl::PointCloud< pcl::PointXYZRGBA >::Ptr &CloudPtr)
Definition: RG_Segmenter.cpp:39
visionx::PointCloudSegmenter::isPipelineStepEnabled
bool isPipelineStepEnabled(const Ice::Current &c=Ice::emptyCurrent) override
Definition: PointCloudSegmenter.cpp:372
visionx::PointCloudSegmenter::setLccpParameters
void setLccpParameters(const LccpParameters &parameters, const Ice::Current &c=Ice::emptyCurrent) override
Definition: PointCloudSegmenter.cpp:384
armarx::flush
const LogSender::manipulator flush
Definition: LogSender.h:251
RGSegClass::UpdateRegionGrowingSegmentationParameters
void UpdateRegionGrowingSegmentationParameters(float SmoothnessThres, float CurvatureThres)
Definition: RG_Segmenter.cpp:90
visionx::PointCloudSegmenter::onInitPointCloudProcessor
void onInitPointCloudProcessor() override
Definition: PointCloudSegmenter.cpp:48
visionx::PointCloudProcessor::waitForPointClouds
bool waitForPointClouds(int milliseconds=1000)
Wait for new PointClouds.
Definition: PointCloudProcessor.cpp:433
TimestampVariant.h
PointCloudSegmenter.h
enabled
std::atomic< bool > * enabled
Definition: RemoteGuiWidgetController.cpp:75
filename
std::string filename
Definition: VisualizationRobot.cpp:83
DeepSegClass
Definition: Deep_Segmenter.h:38
LCCPSegClass::UpdateParameters
void UpdateParameters(float voxelRes, float seedRes, float colorImp, float spatialImp, float normalImp, float concavityThres, float smoothnessThes, uint32_t minSegSize)
Definition: LCCP_Segmenter.cpp:170
visionx::PointCloudSegmenter::loadRgParametersFromFile
void loadRgParametersFromFile(const std::string &filename, const Ice::Current &c=Ice::emptyCurrent) override
Definition: PointCloudSegmenter.cpp:438
visionx::PointCloudSegmenter::enablePipelineStep
void enablePipelineStep(const Ice::Current &c=Ice::emptyCurrent) override
Definition: PointCloudSegmenter.cpp:290
armarx::RemoteGui::Client::FloatSpinBox::setDecimals
void setDecimals(int decimals)
Definition: Widgets.cpp:326
armarx::RemoteGui::Client::FloatSpinBox::setSteps
void setSteps(int steps)
Definition: Widgets.cpp:320
visionx::PointCloudProcessor::getPointClouds
int getPointClouds(const PointCloudPtrT &pointCloudPtr)
Poll PointClouds from provider.
Definition: PointCloudProcessor.h:373
LCCPSegClass
Definition: LCCP_Segmenter.h:50
armarx::armem::Time
armarx::core::time::DateTime Time
Definition: forward_declarations.h:13
for
for(;yybottom<=yytop;yybottom++)
Definition: Grammar.cpp:790
visionx::PointCloudSegmenter::RemoteGui_update
void RemoteGui_update() override
Definition: PointCloudSegmenter.cpp:480
armarx::LightweightRemoteGuiComponentPluginUser::RemoteGui_startRunningTask
void RemoteGui_startRunningTask()
Definition: LightweightRemoteGuiComponentPlugin.cpp:110
visionx::PointCloudSegmenter::loadLccpParametersFromFile
void loadLccpParametersFromFile(const std::string &filename, const Ice::Current &c=Ice::emptyCurrent) override
Definition: PointCloudSegmenter.cpp:392
ExpressionException.h
PointCloud
Definition: PointCloud.h:69
visionx::PointCloudSegmenter::disablePipelineStep
void disablePipelineStep(const Ice::Current &c=Ice::emptyCurrent) override
Definition: PointCloudSegmenter.cpp:298
armarx::Component::getConfigIdentifier
std::string getConfigIdentifier()
Retrieve config identifier for this component as set in constructor.
Definition: Component.cpp:74
PointCloudConversions.h
visionx::PointCloudProcessor::releasePointCloudProvider
void releasePointCloudProvider(std::string providerName)
Removes topic subscription and provider proxy dependency to release a point cloud provider.
Definition: PointCloudProcessor.cpp:275
visionx::PointCloudProcessor::onConnectComponent
virtual void onConnectComponent() override
Definition: PointCloudProcessor.cpp:201
ARMARX_INFO
#define ARMARX_INFO
Definition: Logging.h:174
visionx::PointCloudSegmenter::setRgParameters
void setRgParameters(float smoothnessThreshold, float curvatureThreshold, const Ice::Current &c=Ice::emptyCurrent) override
Definition: PointCloudSegmenter.cpp:432
armarx::LightweightRemoteGuiComponentPluginUser::RemoteGui_createTab
void RemoteGui_createTab(std::string const &name, RemoteGui::Client::Widget const &rootWidget, RemoteGui::Client::Tab *tab)
Definition: LightweightRemoteGuiComponentPlugin.cpp:95
armarx::ManagedIceObject::offeringTopic
void offeringTopic(const std::string &name)
Registers a topic for retrival after initialization.
Definition: ManagedIceObject.cpp:290
IceUtil::Handle< class PropertyDefinitionContainer >
LCCPSegClass::GetSuperVoxelClusterSize
size_t GetSuperVoxelClusterSize()
Definition: LCCP_Segmenter.h:99
DeepSegClass::GetLabeledPointCloud
pcl::PointCloud< pcl::PointXYZRGBL >::Ptr & GetLabeledPointCloud(pcl::PointCloud< pcl::PointXYZRGBA >::Ptr &CloudPtr, armarx::Blob segmentImage)
Definition: Deep_Segmenter.cpp:32
visionx::PointCloudProcessor::usingPointCloudProvider
void usingPointCloudProvider(std::string providerName)
Registers a delayed topic subscription and a delayed provider proxy retrieval which will be available...
Definition: PointCloudProcessor.cpp:261
visionx::PointCloudSegmenterTab::rgCurvatureThreshold
FloatSpinBox rgCurvatureThreshold
Definition: PointCloudSegmenter.h:74
visionx::PointCloudSegmenter::process
void process() override
Definition: PointCloudSegmenter.cpp:152
ARMARX_WARNING
#define ARMARX_WARNING
Definition: Logging.h:186
armarx::PropertyDefinitionsPtr
IceUtil::Handle< class PropertyDefinitionContainer > PropertyDefinitionsPtr
PropertyDefinitions smart pointer type.
Definition: forward_declarations.h:34
visionx::PointO
pcl::PointXYZRGBA PointO
Definition: PointCloudSegmenter.h:63
armarx::ManagedIceObject::usingProxy
bool usingProxy(const std::string &name, const std::string &endpoints="")
Registers a proxy for retrieval after initialization and adds it to the dependency list.
Definition: ManagedIceObject.cpp:151
armarx
This file offers overloads of toIce() and fromIce() functions for STL container types.
Definition: ArmarXTimeserver.cpp:28
LCCPSegClass::GetLabeledPointCloud
pcl::PointCloud< pcl::PointXYZL >::Ptr & GetLabeledPointCloud(pcl::PointCloud< pcl::PointXYZRGBA >::Ptr &CloudPtr)
Definition: LCCP_Segmenter.cpp:77
visionx::PointCloudSegmenter::onExitPointCloudProcessor
void onExitPointCloudProcessor() override
Definition: PointCloudSegmenter.cpp:129
visionx::PointCloudSegmenter::getLastProcessedTimestamp
armarx::TimestampBasePtr getLastProcessedTimestamp(const Ice::Current &c=Ice::emptyCurrent) override
Definition: PointCloudSegmenter.cpp:378