FWIW if the directory structure is always DIR$N/001.$EXT, it has a fixed depth and you don't even need File::Find(::Rule), a simple glob is enough:

use strict;
use warnings;
my %seen;

while (my $file = glob 'Dir*/*') {
     (my $base = $file) =~ s/\.\w+$//;
     next if $seen{$base};
     # work with $file here
}
[download]

I don't know if this helps for anything, this doesn't Iterate Recursively as shown, but I use readdir in the following code to create an array $dots of filenames from a directory, excluding any "." prefix in unix. Then I can grep out anything I don't want to operate on, etc. Or in this case put the contents of all the files into a single array $foo, then grep out or split out whatever I'm looking for. I think it can be modified to do something useful without a module.

  $sd = "../data/data_forthis";
  opendir( DIR, $sd) || die;
  while( ($filename = readdir(DIR))){
    next if "$sd\/$filename" =~ /\/\./;
    push @dots, "$sd\/$filename";
  }  ## end of while
  @dots = sort @dots;
  closedir(DIR);

  for(my $a=0;$a<@dots;$a++){
    open (FILE, $dots[$a]);
    push @foo, <FILE>;
    if ($a+1 eq @dots) {
      close FILE;
      open (FILE, $dots[$a]);
      push @foo2, <FILE>;
      } ## end of if
    close FILE;
  }  ## end of for
### At this point @foo has everything and $foo2 has just the last file
+ in the directory...
[download]

Consider using a hash of arrays (HoA) to track the partial paths (that includes all up to the file extension) and their associated types. For example, given your dataset, the hash would be:

'Dir1/001' => ['jpg'],
'Dir2/002' => ['jpg'],
'Dir2/001' => ['jpg', 'cr2']
[download]

This way you can track 'uniqueness' and the file types of the images:

use strict;
use warnings;
use File::Find::Rule;
use File::Basename;

my %hash;
my $dir = '.';

my @files = File::Find::Rule->file()->in($dir);

for my $file (@files) {
    if ( my ( $partialPath, $type ) = $file =~ /(.+)\.([^.]+)/ ) {
        push @{ $hash{$partialPath} }, $type;
    }

}

for my $partialPath ( keys %hash ) {
    #my @fileTypes = @{ $hash{$partialPath} };
    my $fileTypes = $hash{$partialPath}->[0] ? "@{ $hash{$partialPath}
+ }" : 'None';
    my $baseFilename = basename $partialPath;

    # make thumbnail
    # $partialPath contains all up to trailing dot and extension
    # @fileTypes contains the file type(s)
    # $baseFilename contains the base file name w/o the extension

    print "Partial Path: $partialPath\n";
    print "File Type(s): $fileTypes\nBasename: $baseFilename\n\n";
}
[download]

Hope this helps!

I was thinking about something like that... but I want to do one other thing that doing it that way makes it hard to do... I want to mark the image as having a CR2, JPEG, etc so I know that the image had a RAW... I just don't need two thumbnails. Make sense?

-Eric

Have updated my answer.

#!/usr/bin/env perl

use strict;
use warnings;

use Path::Tiny;
use File::Find::Rule;

my $dir = shift or die 'No directory given.';
my $dir_path = Path::Tiny->new($dir);

my @files = File::Find::Rule->file()->in( $dir_path );

my %file_info;

foreach my $file (@files) {
    my $file_name = path($file)->basename;
    my $fn_without_ext = $file_name;
    $fn_without_ext =~ s/\..{3}$//;
    $file_info{ path($file)->dirname }{ $fn_without_ext } = path($file
+)->basename; 
} 

foreach my $found_dir (keys(%file_info)) {
    my $file_name = (values %{$file_info{$found_dir}})[0];
    my $file_to_process = path($found_dir, $file_name);
    #process the file here (e.g. use the 'system' command)
    print "Processing this file: $file_to_process\n";
}

exit;
[download]