segmentation
•All Data Structures Namespaces Files Functions Variables Modules Pages
SegmentationModuleInterface.cpp
1 /*
2  * Copyright (C) 2006-2020 Istituto Italiano di Tecnologia (IIT)
3  * All rights reserved.
4  *
5  * This software may be modified and distributed under the terms of the
6  * BSD-3-Clause license. See the accompanying LICENSE file for details.
7  */
8 
9 // Autogenerated by Thrift Compiler (0.12.0-yarped)
10 //
11 // This is an automatically generated file.
12 // It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
13 
14 #include <yarp/sig/SegmentationModuleInterface.h>
15 
16 #include <yarp/os/idl/WireTypes.h>
17 
18 namespace yarp {
19 namespace sig {
20 
21 class SegmentationModuleInterface_set_sigma_helper :
22  public yarp::os::Portable
23 {
24 public:
25  explicit SegmentationModuleInterface_set_sigma_helper(const double newValue);
26  bool write(yarp::os::ConnectionWriter& connection) const override;
27  bool read(yarp::os::ConnectionReader& connection) override;
28 
29  double m_newValue;
30 };
31 
32 SegmentationModuleInterface_set_sigma_helper::SegmentationModuleInterface_set_sigma_helper(const double newValue) :
33  m_newValue{newValue}
34 {
35 }
36 
37 bool SegmentationModuleInterface_set_sigma_helper::write(yarp::os::ConnectionWriter& connection) const
38 {
39  yarp::os::idl::WireWriter writer(connection);
40  if (!writer.writeListHeader(3)) {
41  return false;
42  }
43  if (!writer.writeTag("set_sigma", 1, 2)) {
44  return false;
45  }
46  if (!writer.writeFloat64(m_newValue)) {
47  return false;
48  }
49  return true;
50 }
51 
52 bool SegmentationModuleInterface_set_sigma_helper::read(yarp::os::ConnectionReader& connection)
53 {
54  yarp::os::idl::WireReader reader(connection);
55  if (!reader.readListReturn()) {
56  return false;
57  }
58  return true;
59 }
60 
61 class SegmentationModuleInterface_set_k_helper :
62  public yarp::os::Portable
63 {
64 public:
65  explicit SegmentationModuleInterface_set_k_helper(const double newValue);
66  bool write(yarp::os::ConnectionWriter& connection) const override;
67  bool read(yarp::os::ConnectionReader& connection) override;
68 
69  double m_newValue;
70 };
71 
72 SegmentationModuleInterface_set_k_helper::SegmentationModuleInterface_set_k_helper(const double newValue) :
73  m_newValue{newValue}
74 {
75 }
76 
77 bool SegmentationModuleInterface_set_k_helper::write(yarp::os::ConnectionWriter& connection) const
78 {
79  yarp::os::idl::WireWriter writer(connection);
80  if (!writer.writeListHeader(3)) {
81  return false;
82  }
83  if (!writer.writeTag("set_k", 1, 2)) {
84  return false;
85  }
86  if (!writer.writeFloat64(m_newValue)) {
87  return false;
88  }
89  return true;
90 }
91 
92 bool SegmentationModuleInterface_set_k_helper::read(yarp::os::ConnectionReader& connection)
93 {
94  yarp::os::idl::WireReader reader(connection);
95  if (!reader.readListReturn()) {
96  return false;
97  }
98  return true;
99 }
100 
101 class SegmentationModuleInterface_set_minRegion_helper :
102  public yarp::os::Portable
103 {
104 public:
105  explicit SegmentationModuleInterface_set_minRegion_helper(const double newValue);
106  bool write(yarp::os::ConnectionWriter& connection) const override;
107  bool read(yarp::os::ConnectionReader& connection) override;
108 
109  double m_newValue;
110 };
111 
112 SegmentationModuleInterface_set_minRegion_helper::SegmentationModuleInterface_set_minRegion_helper(const double newValue) :
113  m_newValue{newValue}
114 {
115 }
116 
117 bool SegmentationModuleInterface_set_minRegion_helper::write(yarp::os::ConnectionWriter& connection) const
118 {
119  yarp::os::idl::WireWriter writer(connection);
120  if (!writer.writeListHeader(3)) {
121  return false;
122  }
123  if (!writer.writeTag("set_minRegion", 1, 2)) {
124  return false;
125  }
126  if (!writer.writeFloat64(m_newValue)) {
127  return false;
128  }
129  return true;
130 }
131 
132 bool SegmentationModuleInterface_set_minRegion_helper::read(yarp::os::ConnectionReader& connection)
133 {
134  yarp::os::idl::WireReader reader(connection);
135  if (!reader.readListReturn()) {
136  return false;
137  }
138  return true;
139 }
140 
141 class SegmentationModuleInterface_get_sigma_helper :
142  public yarp::os::Portable
143 {
144 public:
145  explicit SegmentationModuleInterface_get_sigma_helper();
146  bool write(yarp::os::ConnectionWriter& connection) const override;
147  bool read(yarp::os::ConnectionReader& connection) override;
148 
149  thread_local static double s_return_helper;
150 };
151 
152 thread_local double SegmentationModuleInterface_get_sigma_helper::s_return_helper = {};
153 
154 SegmentationModuleInterface_get_sigma_helper::SegmentationModuleInterface_get_sigma_helper()
155 {
156  s_return_helper = {};
157 }
158 
159 bool SegmentationModuleInterface_get_sigma_helper::write(yarp::os::ConnectionWriter& connection) const
160 {
161  yarp::os::idl::WireWriter writer(connection);
162  if (!writer.writeListHeader(2)) {
163  return false;
164  }
165  if (!writer.writeTag("get_sigma", 1, 2)) {
166  return false;
167  }
168  return true;
169 }
170 
171 bool SegmentationModuleInterface_get_sigma_helper::read(yarp::os::ConnectionReader& connection)
172 {
173  yarp::os::idl::WireReader reader(connection);
174  if (!reader.readListReturn()) {
175  return false;
176  }
177  if (!reader.readFloat64(s_return_helper)) {
178  reader.fail();
179  return false;
180  }
181  return true;
182 }
183 
184 class SegmentationModuleInterface_get_k_helper :
185  public yarp::os::Portable
186 {
187 public:
188  explicit SegmentationModuleInterface_get_k_helper();
189  bool write(yarp::os::ConnectionWriter& connection) const override;
190  bool read(yarp::os::ConnectionReader& connection) override;
191 
192  thread_local static double s_return_helper;
193 };
194 
195 thread_local double SegmentationModuleInterface_get_k_helper::s_return_helper = {};
196 
197 SegmentationModuleInterface_get_k_helper::SegmentationModuleInterface_get_k_helper()
198 {
199  s_return_helper = {};
200 }
201 
202 bool SegmentationModuleInterface_get_k_helper::write(yarp::os::ConnectionWriter& connection) const
203 {
204  yarp::os::idl::WireWriter writer(connection);
205  if (!writer.writeListHeader(2)) {
206  return false;
207  }
208  if (!writer.writeTag("get_k", 1, 2)) {
209  return false;
210  }
211  return true;
212 }
213 
214 bool SegmentationModuleInterface_get_k_helper::read(yarp::os::ConnectionReader& connection)
215 {
216  yarp::os::idl::WireReader reader(connection);
217  if (!reader.readListReturn()) {
218  return false;
219  }
220  if (!reader.readFloat64(s_return_helper)) {
221  reader.fail();
222  return false;
223  }
224  return true;
225 }
226 
227 class SegmentationModuleInterface_get_minRegion_helper :
228  public yarp::os::Portable
229 {
230 public:
231  explicit SegmentationModuleInterface_get_minRegion_helper();
232  bool write(yarp::os::ConnectionWriter& connection) const override;
233  bool read(yarp::os::ConnectionReader& connection) override;
234 
235  thread_local static double s_return_helper;
236 };
237 
238 thread_local double SegmentationModuleInterface_get_minRegion_helper::s_return_helper = {};
239 
240 SegmentationModuleInterface_get_minRegion_helper::SegmentationModuleInterface_get_minRegion_helper()
241 {
242  s_return_helper = {};
243 }
244 
245 bool SegmentationModuleInterface_get_minRegion_helper::write(yarp::os::ConnectionWriter& connection) const
246 {
247  yarp::os::idl::WireWriter writer(connection);
248  if (!writer.writeListHeader(2)) {
249  return false;
250  }
251  if (!writer.writeTag("get_minRegion", 1, 2)) {
252  return false;
253  }
254  return true;
255 }
256 
257 bool SegmentationModuleInterface_get_minRegion_helper::read(yarp::os::ConnectionReader& connection)
258 {
259  yarp::os::idl::WireReader reader(connection);
260  if (!reader.readListReturn()) {
261  return false;
262  }
263  if (!reader.readFloat64(s_return_helper)) {
264  reader.fail();
265  return false;
266  }
267  return true;
268 }
269 
270 class SegmentationModuleInterface_get_num_components_helper :
271  public yarp::os::Portable
272 {
273 public:
274  explicit SegmentationModuleInterface_get_num_components_helper();
275  bool write(yarp::os::ConnectionWriter& connection) const override;
276  bool read(yarp::os::ConnectionReader& connection) override;
277 
278  thread_local static std::int32_t s_return_helper;
279 };
280 
281 thread_local std::int32_t SegmentationModuleInterface_get_num_components_helper::s_return_helper = {};
282 
283 SegmentationModuleInterface_get_num_components_helper::SegmentationModuleInterface_get_num_components_helper()
284 {
285  s_return_helper = {};
286 }
287 
288 bool SegmentationModuleInterface_get_num_components_helper::write(yarp::os::ConnectionWriter& connection) const
289 {
290  yarp::os::idl::WireWriter writer(connection);
291  if (!writer.writeListHeader(3)) {
292  return false;
293  }
294  if (!writer.writeTag("get_num_components", 1, 3)) {
295  return false;
296  }
297  return true;
298 }
299 
300 bool SegmentationModuleInterface_get_num_components_helper::read(yarp::os::ConnectionReader& connection)
301 {
302  yarp::os::idl::WireReader reader(connection);
303  if (!reader.readListReturn()) {
304  return false;
305  }
306  if (!reader.readI32(s_return_helper)) {
307  reader.fail();
308  return false;
309  }
310  return true;
311 }
312 
313 class SegmentationModuleInterface_get_component_around_helper :
314  public yarp::os::Portable
315 {
316 public:
317  explicit SegmentationModuleInterface_get_component_around_helper(const Pixel& objCenter);
318  bool write(yarp::os::ConnectionWriter& connection) const override;
319  bool read(yarp::os::ConnectionReader& connection) override;
320 
321  Pixel m_objCenter;
322 
323  thread_local static std::vector<Pixel> s_return_helper;
324 };
325 
326 thread_local std::vector<Pixel> SegmentationModuleInterface_get_component_around_helper::s_return_helper = {};
327 
328 SegmentationModuleInterface_get_component_around_helper::SegmentationModuleInterface_get_component_around_helper(const Pixel& objCenter) :
329  m_objCenter{objCenter}
330 {
331 }
332 
333 bool SegmentationModuleInterface_get_component_around_helper::write(yarp::os::ConnectionWriter& connection) const
334 {
335  yarp::os::idl::WireWriter writer(connection);
336  if (!writer.writeListHeader(5)) {
337  return false;
338  }
339  if (!writer.writeTag("get_component_around", 1, 3)) {
340  return false;
341  }
342  if (!writer.write(m_objCenter)) {
343  return false;
344  }
345  return true;
346 }
347 
348 bool SegmentationModuleInterface_get_component_around_helper::read(yarp::os::ConnectionReader& connection)
349 {
350  yarp::os::idl::WireReader reader(connection);
351  if (!reader.readListReturn()) {
352  return false;
353  }
354  s_return_helper.clear();
355  uint32_t _size0;
356  yarp::os::idl::WireState _etype3;
357  reader.readListBegin(_etype3, _size0);
358  s_return_helper.resize(_size0);
359  for (size_t _i4 = 0; _i4 < _size0; ++_i4) {
360  if (!reader.readNested(s_return_helper[_i4])) {
361  reader.fail();
362  return false;
363  }
364  }
365  reader.readListEnd();
366  return true;
367 }
368 
369 // Constructor
370 SegmentationModuleInterface::SegmentationModuleInterface()
371 {
372  yarp().setOwner(*this);
373 }
374 
375 void SegmentationModuleInterface::set_sigma(const double newValue)
376 {
377  SegmentationModuleInterface_set_sigma_helper helper{newValue};
378  if (!yarp().canWrite()) {
379  yError("Missing server method '%s'?", "void SegmentationModuleInterface::set_sigma(const double newValue)");
380  }
381  yarp().write(helper, helper);
382 }
383 
384 void SegmentationModuleInterface::set_k(const double newValue)
385 {
386  SegmentationModuleInterface_set_k_helper helper{newValue};
387  if (!yarp().canWrite()) {
388  yError("Missing server method '%s'?", "void SegmentationModuleInterface::set_k(const double newValue)");
389  }
390  yarp().write(helper, helper);
391 }
392 
393 void SegmentationModuleInterface::set_minRegion(const double newValue)
394 {
395  SegmentationModuleInterface_set_minRegion_helper helper{newValue};
396  if (!yarp().canWrite()) {
397  yError("Missing server method '%s'?", "void SegmentationModuleInterface::set_minRegion(const double newValue)");
398  }
399  yarp().write(helper, helper);
400 }
401 
402 double SegmentationModuleInterface::get_sigma()
403 {
404  SegmentationModuleInterface_get_sigma_helper helper{};
405  if (!yarp().canWrite()) {
406  yError("Missing server method '%s'?", "double SegmentationModuleInterface::get_sigma()");
407  }
408  bool ok = yarp().write(helper, helper);
409  return ok ? SegmentationModuleInterface_get_sigma_helper::s_return_helper : double{};
410 }
411 
412 double SegmentationModuleInterface::get_k()
413 {
414  SegmentationModuleInterface_get_k_helper helper{};
415  if (!yarp().canWrite()) {
416  yError("Missing server method '%s'?", "double SegmentationModuleInterface::get_k()");
417  }
418  bool ok = yarp().write(helper, helper);
419  return ok ? SegmentationModuleInterface_get_k_helper::s_return_helper : double{};
420 }
421 
422 double SegmentationModuleInterface::get_minRegion()
423 {
424  SegmentationModuleInterface_get_minRegion_helper helper{};
425  if (!yarp().canWrite()) {
426  yError("Missing server method '%s'?", "double SegmentationModuleInterface::get_minRegion()");
427  }
428  bool ok = yarp().write(helper, helper);
429  return ok ? SegmentationModuleInterface_get_minRegion_helper::s_return_helper : double{};
430 }
431 
432 std::int32_t SegmentationModuleInterface::get_num_components()
433 {
434  SegmentationModuleInterface_get_num_components_helper helper{};
435  if (!yarp().canWrite()) {
436  yError("Missing server method '%s'?", "std::int32_t SegmentationModuleInterface::get_num_components()");
437  }
438  bool ok = yarp().write(helper, helper);
439  return ok ? SegmentationModuleInterface_get_num_components_helper::s_return_helper : std::int32_t{};
440 }
441 
442 std::vector<Pixel> SegmentationModuleInterface::get_component_around(const Pixel& objCenter)
443 {
444  SegmentationModuleInterface_get_component_around_helper helper{objCenter};
445  if (!yarp().canWrite()) {
446  yError("Missing server method '%s'?", "std::vector<Pixel> SegmentationModuleInterface::get_component_around(const Pixel& objCenter)");
447  }
448  bool ok = yarp().write(helper, helper);
449  return ok ? SegmentationModuleInterface_get_component_around_helper::s_return_helper : std::vector<Pixel>{};
450 }
451 
452 // help method
453 std::vector<std::string> SegmentationModuleInterface::help(const std::string& functionName)
454 {
455  bool showAll = (functionName == "--all");
456  std::vector<std::string> helpString;
457  if (showAll) {
458  helpString.emplace_back("*** Available commands:");
459  helpString.emplace_back("set_sigma");
460  helpString.emplace_back("set_k");
461  helpString.emplace_back("set_minRegion");
462  helpString.emplace_back("get_sigma");
463  helpString.emplace_back("get_k");
464  helpString.emplace_back("get_minRegion");
465  helpString.emplace_back("get_num_components");
466  helpString.emplace_back("get_component_around");
467  helpString.emplace_back("help");
468  } else {
469  if (functionName == "set_sigma") {
470  helpString.emplace_back("void set_sigma(const double newValue) ");
471  helpString.emplace_back("Set sigma (smoothing) parameter for the algorithm ");
472  helpString.emplace_back("@param newValue new value for sigma parameter ");
473  }
474  if (functionName == "set_k") {
475  helpString.emplace_back("void set_k(const double newValue) ");
476  helpString.emplace_back("Set k (scale factor for boundary-detection threshold function) parameter for the algorithm ");
477  helpString.emplace_back("@param newValue new value for k parameter ");
478  }
479  if (functionName == "set_minRegion") {
480  helpString.emplace_back("void set_minRegion(const double newValue) ");
481  helpString.emplace_back("Set minRegion parameter for the algorithm, i.e., the minimum size of any segmented component ");
482  helpString.emplace_back("@param newValue new value for minRegion parameter ");
483  }
484  if (functionName == "get_sigma") {
485  helpString.emplace_back("double get_sigma() ");
486  helpString.emplace_back("Get sigma (smoothing) parameter for the algorithm ");
487  helpString.emplace_back("@return current value for sigma parameter ");
488  }
489  if (functionName == "get_k") {
490  helpString.emplace_back("double get_k() ");
491  helpString.emplace_back("Get k (scale factor for boundary-detection threshold function) parameter for the algorithm ");
492  helpString.emplace_back("@return current value for k parameter ");
493  }
494  if (functionName == "get_minRegion") {
495  helpString.emplace_back("double get_minRegion() ");
496  helpString.emplace_back("Get minRegion parameter for the algorithm, i.e., the minimum size of any segmented component ");
497  helpString.emplace_back("@return current value for minRegion parameter ");
498  }
499  if (functionName == "get_num_components") {
500  helpString.emplace_back("std::int32_t get_num_components() ");
501  helpString.emplace_back("Get the number of segmented components that have been detected in the last provided image ");
502  helpString.emplace_back("@return number of segmented components ");
503  }
504  if (functionName == "get_component_around") {
505  helpString.emplace_back("std::vector<Pixel> get_component_around(const Pixel& objCenter) ");
506  helpString.emplace_back("Get the list of pixels corresponding to the component to which a given pixel belongs ");
507  helpString.emplace_back("@param objCenter a pixel belonging to the region of interest ");
508  helpString.emplace_back("@return list of pixels belonging to the same component as the input pixels ");
509  }
510  if (functionName == "help") {
511  helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
512  helpString.emplace_back("Return list of available commands, or help message for a specific function");
513  helpString.emplace_back("@param functionName name of command for which to get a detailed description. If none or '--all' is provided, print list of available commands");
514  helpString.emplace_back("@return list of strings (one string per line)");
515  }
516  }
517  if (helpString.empty()) {
518  helpString.emplace_back("Command not found");
519  }
520  return helpString;
521 }
522 
523 // read from ConnectionReader
524 bool SegmentationModuleInterface::read(yarp::os::ConnectionReader& connection)
525 {
526  yarp::os::idl::WireReader reader(connection);
527  reader.expectAccept();
528  if (!reader.readListHeader()) {
529  reader.fail();
530  return false;
531  }
532 
533  std::string tag = reader.readTag();
534  bool direct = (tag == "__direct__");
535  if (direct) {
536  tag = reader.readTag();
537  }
538  while (!reader.isError()) {
539  if (tag == "set_sigma") {
540  double newValue;
541  if (!reader.readFloat64(newValue)) {
542  reader.fail();
543  return false;
544  }
545  set_sigma(newValue);
546  yarp::os::idl::WireWriter writer(reader);
547  if (!writer.isNull()) {
548  if (!writer.writeListHeader(0)) {
549  return false;
550  }
551  }
552  reader.accept();
553  return true;
554  }
555  if (tag == "set_k") {
556  double newValue;
557  if (!reader.readFloat64(newValue)) {
558  reader.fail();
559  return false;
560  }
561  set_k(newValue);
562  yarp::os::idl::WireWriter writer(reader);
563  if (!writer.isNull()) {
564  if (!writer.writeListHeader(0)) {
565  return false;
566  }
567  }
568  reader.accept();
569  return true;
570  }
571  if (tag == "set_minRegion") {
572  double newValue;
573  if (!reader.readFloat64(newValue)) {
574  reader.fail();
575  return false;
576  }
577  set_minRegion(newValue);
578  yarp::os::idl::WireWriter writer(reader);
579  if (!writer.isNull()) {
580  if (!writer.writeListHeader(0)) {
581  return false;
582  }
583  }
584  reader.accept();
585  return true;
586  }
587  if (tag == "get_sigma") {
588  SegmentationModuleInterface_get_sigma_helper::s_return_helper = get_sigma();
589  yarp::os::idl::WireWriter writer(reader);
590  if (!writer.isNull()) {
591  if (!writer.writeListHeader(1)) {
592  return false;
593  }
594  if (!writer.writeFloat64(SegmentationModuleInterface_get_sigma_helper::s_return_helper)) {
595  return false;
596  }
597  }
598  reader.accept();
599  return true;
600  }
601  if (tag == "get_k") {
602  SegmentationModuleInterface_get_k_helper::s_return_helper = get_k();
603  yarp::os::idl::WireWriter writer(reader);
604  if (!writer.isNull()) {
605  if (!writer.writeListHeader(1)) {
606  return false;
607  }
608  if (!writer.writeFloat64(SegmentationModuleInterface_get_k_helper::s_return_helper)) {
609  return false;
610  }
611  }
612  reader.accept();
613  return true;
614  }
615  if (tag == "get_minRegion") {
616  SegmentationModuleInterface_get_minRegion_helper::s_return_helper = get_minRegion();
617  yarp::os::idl::WireWriter writer(reader);
618  if (!writer.isNull()) {
619  if (!writer.writeListHeader(1)) {
620  return false;
621  }
622  if (!writer.writeFloat64(SegmentationModuleInterface_get_minRegion_helper::s_return_helper)) {
623  return false;
624  }
625  }
626  reader.accept();
627  return true;
628  }
629  if (tag == "get_num_components") {
630  SegmentationModuleInterface_get_num_components_helper::s_return_helper = get_num_components();
631  yarp::os::idl::WireWriter writer(reader);
632  if (!writer.isNull()) {
633  if (!writer.writeListHeader(1)) {
634  return false;
635  }
636  if (!writer.writeI32(SegmentationModuleInterface_get_num_components_helper::s_return_helper)) {
637  return false;
638  }
639  }
640  reader.accept();
641  return true;
642  }
643  if (tag == "get_component_around") {
644  Pixel objCenter;
645  if (!reader.read(objCenter)) {
646  reader.fail();
647  return false;
648  }
649  SegmentationModuleInterface_get_component_around_helper::s_return_helper = get_component_around(objCenter);
650  yarp::os::idl::WireWriter writer(reader);
651  if (!writer.isNull()) {
652  if (!writer.writeListHeader(1)) {
653  return false;
654  }
655  if (!writer.writeListBegin(BOTTLE_TAG_LIST, static_cast<uint32_t>(SegmentationModuleInterface_get_component_around_helper::s_return_helper.size()))) {
656  return false;
657  }
658  for (const auto& _item5 : SegmentationModuleInterface_get_component_around_helper::s_return_helper) {
659  if (!writer.writeNested(_item5)) {
660  return false;
661  }
662  }
663  if (!writer.writeListEnd()) {
664  return false;
665  }
666  }
667  reader.accept();
668  return true;
669  }
670  if (tag == "help") {
671  std::string functionName;
672  if (!reader.readString(functionName)) {
673  functionName = "--all";
674  }
675  auto help_strings = help(functionName);
676  yarp::os::idl::WireWriter writer(reader);
677  if (!writer.isNull()) {
678  if (!writer.writeListHeader(2)) {
679  return false;
680  }
681  if (!writer.writeTag("many", 1, 0)) {
682  return false;
683  }
684  if (!writer.writeListBegin(BOTTLE_TAG_INT32, static_cast<uint32_t>(help_strings.size()))) {
685  return false;
686  }
687  for (const auto& help_string : help_strings) {
688  if (!writer.writeString(help_string)) {
689  return false;
690  }
691  }
692  if (!writer.writeListEnd()) {
693  return false;
694  }
695  }
696  reader.accept();
697  return true;
698  }
699  if (reader.noMore()) {
700  reader.fail();
701  return false;
702  }
703  std::string next_tag = reader.readTag();
704  if (next_tag == "") {
705  break;
706  }
707  tag.append("_").append(next_tag);
708  }
709  return false;
710 }
711 
712 } // namespace yarp
713 } // namespace sig
yarp::sig::Pixel
Pixel position in the image frame.
Definition: Pixel.h:28
Generated by doxygen 1.9.1