Re: Image sequence listing ...
On Dec 20, 10:44 pm, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
majestik...@gmail.com wrote:
On Dec 20, 1:27 pm, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
majestik...@gmail.com wrote:
[..]
Well I guess my c++ question is about
how do you list a folder, and while doing that
collapsing the filenames that are in the form prefix.%d.suffix
into "groups" like prefix.[first-last].suffix
it's not image related really, just about how to work out
the strings to collapes into one.
Ah... OK. Folders aside, files aside, your question is what you
should do to form "blah.[N-M].blah" if you have a bunch of strings
all containing "blah.<N>.blah", "blah.<N+1>.blah", etc., until the
"blah.<M>.blah" where N and M are two numbers. Right?
This is not a C++ language question. It's an algorithm question.
You need an algorithm for string processing. I would probably
suggest something like
// find the beginning of the sequence
int N;
for (N = 0; N < INT_MAX; ++N) {
std::ostringstream os;
os << "prefix." << N << ".suffix";
std::string filename(os.str());
if (/* exists the file with pattern 'filename' */)
break;
}
// now N is your start
int M;
for (int M = N; M<INT_MAX; ++M) {
std::ostringstream os;
os << "prefix." << M << ".suffix";
std::string filenam(os.str());
if (/* does NOT exist file with pattern 'filename' */)
break;
}
if (--M > N) { // got the sequence!
std::ostringstream os;
os << "prefix.[" << N << '-' << M << "].suffix";
return os.str(); // here you go
}
else { // it's a single file, maybe.
...
}
well yes it's the problem, but the initial conditions are a
bit different let's say i have a list of strings in the form
you mentioned prefix.<N>.suffix, I can have different
prefixes etc. but I guess I cannot avoid going through the
files one by one and looking if i can join it with other
files in the same folder.
It's all in how you check for the existence of the file. If
your system allows enumerating with a pattern (like
"*.1001.img"), then you're in luck and you need to put the
asterisk instead of 'prefix'.
The algorithm as I wrote it is also substandard from the
performance point of view.
Two quick comments: boost::regex would be useful for determining
patterns. Note too that if the strings are sorted (which he
probably wants to do anyway, if they are in fact filenames), all
of the candidates for a match will be adjacent. Taking
advantage of this pre-condition, something like the following
should work:
int
asNumber(
std::string const& str )
{
std::istringstream s( str ) ;
int i ;
s >> i >> std::ws ;
return s && s.get() == EOF && i >= 0
? i
: -1 ;
}
template< typename FwdIter, typename OutIter >
void
collapse(
FwdIter begin,
FwdIter end,
OutIter dest )
{
static boost::regex const
matcher(
"^\\(.*\\)\\.\\([1-9]\\d*\\)\\.\\(.*\\)$" ) ;
boost::smatch results ;
while ( begin != end ) {
if ( ! boost::regex_match( *begin, results, matcher ) ) {
*dest = *begin ;
++ dest ;
++ begin ;
} else {
std::string prefix = results[ 1 ] ;
int start =
asNumber( results[ 2 ] ) ;
std::string suffix = results[ 3 ] ;
int expect = start + 1 ;
++ begin ;
while ( boost::regex_match( *begin, results, matcher)
&& results[ 1 ] == prefix
&& asNumber( results[ 2 ] ) == expect
&& results[ 3 ] == suffix ) {
++ begin ;
++ expect ;
}
std::ostringstream s ;
s << prefix << ".[" << start << '-'
<< expect << "]." << suffix ;
*dest = s.str() ;
++ dest ;
}
}
}
(Note that since I haven't got Boost installed on the machine
here, I can't test it. But the general idea should work.)
As for performance, just about anything he does will be hardly
noticeable compared to the time it takes to read the directory
into memory to begin with.
It would be nice if you could simply get all the
strings (names of the files) fitting the pattern "*.[0-9]+.suffix",
and sort them while disregarding the prefix (you need a custom
comparison functor for that).
This should be possible; at least, it's possible with my
implementation of File. But reading the directory several times
is probably not the best solution. Read everything into memory
once, and work there. (Where your suggestion here is nothing
more than copy_if with a regular expression based predicate.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34