Visual Servoing Platform  version 3.5.1 under development (2023-03-29)
vpDiskGrabber.cpp
1 /****************************************************************************
2  *
3  * ViSP, open source Visual Servoing Platform software.
4  * Copyright (C) 2005 - 2022 by Inria. All rights reserved.
5  *
6  * This software is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  * See the file LICENSE.txt at the root directory of this source
11  * distribution for additional information about the GNU GPL.
12  *
13  * For using ViSP with software that can not be combined with the GNU
14  * GPL, please contact Inria about acquiring a ViSP Professional
15  * Edition License.
16  *
17  * See http://visp.inria.fr for more information.
18  *
19  * This software was developed at:
20  * Inria Rennes - Bretagne Atlantique
21  * Campus Universitaire de Beaulieu
22  * 35042 Rennes Cedex
23  * France
24  *
25  * If you have questions regarding the use of this file, please contact
26  * Inria at visp@inria.fr
27  *
28  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
29  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30  *
31  * Description:
32  * Disk framegrabber.
33  *
34  *****************************************************************************/
35 
36 #include <visp3/io/vpDiskGrabber.h>
37 
42  : m_image_number(0), m_image_number_next(0), m_image_step(1), m_number_of_zero(0), m_directory("/tmp"),
43  m_base_name("I"), m_extension("pgm"), m_use_generic_name(false), m_generic_name("empty")
44 {
45  init = false;
46 }
47 
51 vpDiskGrabber::vpDiskGrabber(const std::string &generic_name)
52  : m_image_number(0), m_image_number_next(0), m_image_step(1), m_number_of_zero(0), m_directory("/tmp"),
53  m_base_name("I"), m_extension("pgm"), m_use_generic_name(true), m_generic_name(generic_name)
54 {
55  init = false;
56 }
57 
69 vpDiskGrabber::vpDiskGrabber(const std::string &dir, const std::string &basename, long number, int step,
70  unsigned int noz, const std::string &ext)
71  : m_image_number(number), m_image_number_next(number), m_image_step(step), m_number_of_zero(noz), m_directory(dir),
72  m_base_name(basename), m_extension(ext), m_use_generic_name(false), m_generic_name("empty"), m_image_name()
73 {
74  init = false;
75 }
76 
82 {
83  long first_number = getImageNumber();
84 
85  acquire(I);
86 
87  setImageNumber(first_number);
88 
89  width = I.getWidth();
90  height = I.getHeight();
91 
92  init = true;
93 }
94 
100 {
101  // First we save the image number, so that it can be reaffected after the
102  // acquisition. That means that the first image is readed twice
103  long first_number = getImageNumber();
104 
105  acquire(I);
106 
107  setImageNumber(first_number);
108 
109  width = I.getWidth();
110  height = I.getHeight();
111 
112  init = true;
113 }
114 
120 {
121  // First we save the image number, so that it can be reaffected after the
122  // acquisition. That means that the first image is readed twice
123  long first_number = getImageNumber();
124 
125  acquire(I);
126 
127  setImageNumber(first_number);
128 
129  width = I.getWidth();
130  height = I.getHeight();
131 
132  init = true;
133 }
134 
142 {
143  m_image_number = m_image_number_next;
144  std::stringstream ss;
145 
146  if (m_use_generic_name) {
147  char filename[FILENAME_MAX];
148  snprintf(filename, FILENAME_MAX, m_generic_name.c_str(), m_image_number);
149  ss << filename;
150  } else {
151  ss << m_directory << "/" << m_base_name << std::setfill('0') << std::setw(m_number_of_zero) << m_image_number << "."
152  << m_extension;
153  }
154 
155  m_image_number_next += m_image_step;
156  m_image_name = ss.str();
157  vpImageIo::read(I, m_image_name);
158 
159  width = I.getWidth();
160  height = I.getHeight();
161 }
162 
170 {
171  m_image_number = m_image_number_next;
172  std::stringstream ss;
173 
174  if (m_use_generic_name) {
175  char filename[FILENAME_MAX];
176  snprintf(filename, FILENAME_MAX, m_generic_name.c_str(), m_image_number);
177  ss << filename;
178  } else {
179  ss << m_directory << "/" << m_base_name << std::setfill('0') << std::setw(m_number_of_zero) << m_image_number << "."
180  << m_extension;
181  }
182 
183  m_image_number_next += m_image_step;
184  m_image_name = ss.str();
185  vpImageIo::read(I, m_image_name);
186 
187  width = I.getWidth();
188  height = I.getHeight();
189 }
190 
198 {
199  m_image_number = m_image_number_next;
200  std::stringstream ss;
201  if (m_use_generic_name) {
202  char filename[FILENAME_MAX];
203  snprintf(filename, FILENAME_MAX, m_generic_name.c_str(), m_image_number);
204  ss << filename;
205  } else {
206  ss << m_directory << "/" << m_base_name << std::setfill('0') << std::setw(m_number_of_zero) << m_image_number << "."
207  << m_extension;
208  }
209 
210  m_image_number_next += m_image_step;
211 
212  vpImageIo::readPFM(I, ss.str());
213 
214  width = I.getWidth();
215  height = I.getHeight();
216 }
217 
226 {
227  m_image_number = img_number;
228  std::stringstream ss;
229  if (m_use_generic_name) {
230  char filename[FILENAME_MAX];
231  snprintf(filename, FILENAME_MAX, m_generic_name.c_str(), m_image_number);
232  ss << filename;
233  } else {
234  ss << m_directory << "/" << m_base_name << std::setfill('0') << std::setw(m_number_of_zero) << m_image_number << "."
235  << m_extension;
236  }
237 
238  m_image_number_next = m_image_number + m_image_step;
239 
240  vpImageIo::read(I, ss.str());
241 
242  width = I.getWidth();
243  height = I.getHeight();
244 }
245 
253 void vpDiskGrabber::acquire(vpImage<vpRGBa> &I, long img_number)
254 {
255  m_image_number = img_number;
256  std::stringstream ss;
257  if (m_use_generic_name) {
258  char filename[FILENAME_MAX];
259  snprintf(filename, FILENAME_MAX, m_generic_name.c_str(), m_image_number);
260  ss << filename;
261  } else {
262  ss << m_directory << "/" << m_base_name << std::setfill('0') << std::setw(m_number_of_zero) << m_image_number << "."
263  << m_extension;
264  }
265 
266  m_image_number_next = m_image_number + m_image_step;
267 
268  vpImageIo::read(I, ss.str());
269 
270  width = I.getWidth();
271  height = I.getHeight();
272 }
273 
281 void vpDiskGrabber::acquire(vpImage<float> &I, long img_number)
282 {
283  m_image_number = m_image_number_next;
284  std::stringstream ss;
285  if (m_use_generic_name) {
286  char filename[FILENAME_MAX];
287  snprintf(filename, FILENAME_MAX, m_generic_name.c_str(), m_image_number);
288  ss << filename;
289  } else {
290  ss << m_directory << "/" << m_base_name << std::setfill('0') << std::setw(m_number_of_zero) << img_number << "."
291  << m_extension;
292  }
293 
294  m_image_number_next += m_image_step;
295 
296  vpImageIo::readPFM(I, ss.str());
297 
298  width = I.getWidth();
299  height = I.getHeight();
300 }
301 
308 {
309  // Nothing do do here...
310 }
311 
318 
322 void vpDiskGrabber::setDirectory(const std::string &dir) { m_directory = dir; }
323 
327 void vpDiskGrabber::setBaseName(const std::string &name) { m_base_name = name; }
328 
332 void vpDiskGrabber::setExtension(const std::string &ext) { m_extension = ext; }
333 
338 {
339  m_image_number = number;
340  m_image_number_next = number;
341 }
342 
346 void vpDiskGrabber::setStep(long step) { m_image_step = step; }
350 void vpDiskGrabber::setNumberOfZero(unsigned int noz) { m_number_of_zero = noz; }
351 
352 void vpDiskGrabber::setGenericName(const std::string &generic_name)
353 {
354  m_generic_name = generic_name;
355  m_use_generic_name = true;
356 }
void setStep(long step)
virtual ~vpDiskGrabber()
void setDirectory(const std::string &dir)
void setExtension(const std::string &ext)
void open(vpImage< unsigned char > &I)
void setGenericName(const std::string &genericName)
void setImageNumber(long number)
void setNumberOfZero(unsigned int noz)
void setBaseName(const std::string &name)
long getImageNumber() const
void acquire(vpImage< unsigned char > &I)
unsigned int height
Number of rows in the image.
bool init
Set to true if the frame grabber has been initialized.
unsigned int width
Number of columns in the image.
static void readPFM(vpImage< float > &I, const std::string &filename)
Definition: vpImageIo.cpp:971
static void read(vpImage< unsigned char > &I, const std::string &filename, int backend=IO_DEFAULT_BACKEND)
Definition: vpImageIo.cpp:148
unsigned int getWidth() const
Definition: vpImage.h:247
unsigned int getHeight() const
Definition: vpImage.h:189