" I can't make it works"
I would like to have one € each time I read this one this forum...
What doesn't work? It doesn't compile? It doesn't load the images? It crashes with an error?

You pass PApplet in th constructor, but you don't use / store it, so you have to pass it again in loadImage(). You can avoid this additional parameter.
On a quick glance, the code seems OK, so more explanations on your problems are welcome.

Err, not all OK, actually (the last glance revealed a problem).
The call is just strange, you make a function call with a syntax of a function declaration!
It should not be Textures_loader.loadImage(PApplet app, String filename); at all.
You must make an instance of the class, then call it with the proper parameters.

class Textures_loader extends Thread
{
  // Moved into the class
  String filename;
  PApplet app;
  PImage image;

  Textures_loader(PApplet _app, String _filename)
  {
    filename = _filename; // You inverted the field and the parameter!
    app = _app;
  }

  public PImage loadImage() {  // Removed the parameters, they were redundant with those of the constructor
  // [...] cut for brevity
  }
  public void run()
  {
    try { // ? Processing doesn't throw exceptions...
      image = loadImage();
    }
    catch (Exception e) {
      println("No Video Image: "+ e);
    }
  }
}

thanks philo ! I just didn't know how to start because of lot of errors…but I should have taken themp one by one, which I'm trying to ;)

the original class can display pictures like this:

1. Textures_loader queue;  
   
2.  image(queue.loadImage(this, file), 0, 0, 800, 800);

this is what I would like to do- but this line, when I use your corrected code,it  gives me:

the method loadImage() in the thread_load_simple.Textures_loader is not applicable for the arguments (thread_load_Simple,String) (thread_load_Simple is the name of my sketch)

 

if I understand correctly the orginal code, this part plays that role : Am I wrong ?

1.  public PImage loadImage() {  // Removed the parameters, they were redundant with those of the constructor
       HashMap<String, PImage> textures = new HashMap<String, PImage>();
       if (textures.containsKey(filename)) {
         return textures.get(filename);
       }

If you load the image in a thread, you cannot use it the way you show. You have to create the instance of the class, to run the thread, and to do an action when the loading is completed. It is much more complex than you think.
Image loading is generally fast (unless you have a very big image), so I am not sure why you want to use a thread there.

Actually, my advice isn't good: the way I described, the hash map is useless.
You would need to run the thread, which would be idle most of the time. loadImage() would query if it is in the hash. If so, it returns immediately, otherwise it would make the loop in run() to start the image loading. Then, when the loading is complete, it would add the image to the hash, and notify the main thread that it is available.
That's the tricky part: how your sketch is using these asynchronously loaded images. It has to be designed so images not available immediately can be used later. Then, either it pools regularly the loading thread to check if the image is loaded at least, or to be notified via a callback function of the end of the loading. The best solution depends on your exact needs.

my goal is : visualise a lot of pictures with about 25 images pre-loading and 5 players to make some fading transitions between them really smooth and fast. So when the "target" is pictures 450.jpg for instance, it means, the user can see picture 448,449,450,451,452 blended together. And if he goes fast to target 460, it would be ok because this image is already load into the ram. I make some array comparaison in order to load just new pictures needed and remove the unused ones.this mean I need to load and remove between 5 and 10 images, and of course I don't want those operations avoid displaying images that are already into the ram.

this my difficulty: include hashmap to control the loading thread, and also removing pictures I don't need any more from the ram.
So if I understand you correctly, the hashmap would be in an another class, which launch the loadimage query according if the picture is or not into the ram ?  would it be some simple samples of thing like that ? I mean thread with callbacks ? I suppose I would need interfaces to make class communicating themselves ?
thanks for your concern.
/pauline

Indeed, an interface is a solution.
I believe a LinkedHashMap is a perfect fit for your need.
Or perhaps a simple queue, actually. A hash map would be more suited for random access.
I will try and make a simple proof of concept, as it is an interesting little challenge.

Here is a simple slide-show where images are loaded on demand. Loading a new image after some time should be simple, and changing the translation to your transition shouldn't be too hard.

1. import java.io.*;
2. import java.util.*;
3. final int MAX_IMAGES = 5;
4. final int MAX_IMAGE_WIDTH = 200;
5. final String PATH = "G:/Images/";
6. String[] images;
7. ImageLoader loader;
8. int counter;
9. int position;
10.  
11. void setup()
12. {
13.   size(1200, 400);
14.   imageMode(CENTER);
15.  
16.   File imageDir = new File(PATH);
17.   images = imageDir.list(new FilenameFilter()
18.   {
19.     public boolean accept(File dir, String name)
20.     {
21.       return name.endsWith(".gif") ||
22.           name.endsWith(".jpg") ||
23.           name.endsWith(".png");
24.     }
25.   });
26. //  println(images);
27.   loader = new ImageLoader();
28.   loader.start();
29.   println("Starting");
30. }
31.  
32. void draw()
33. {
34.   background(255);
35.   int c = 0;
36.   for (PImage image : loader)
37.   {
38.     int pos = position - c++ * MAX_IMAGE_WIDTH;
39.     if (pos > width)
40.     {
41.       pos -= width;
42.     }
43.     image(image, pos, height / 2);
44.   }
45.   position++;
46. }
47.  
48. void keyPressed()
49. {
50.   counter %= images.length;
51.   String path = PATH + images[counter++];
52.   println("Loading " + path);
53.   loader.requestImage(path);
54. }
55.  
56.  
57. class ImageLoader extends Thread implements Iterable<PImage>
58. {
59.   boolean running;
60.   ArrayDeque<PImage> images = new ArrayDeque<PImage>();
61.   String imageToLoad;
62.  
63.   ImageLoader()
64.   {
65.     running = true;
66.   }
67.   
68.   void requestImage(String fileName)
69.   {
70.     imageToLoad = fileName;
71.   }
72.   
73.   public Iterator<PImage> iterator()
74.   {
75.     return images.iterator();
76.   }
77.   
78.   public void run()
79.   {
80.     while (running)
81.     {
82.       if (imageToLoad != null)
83.       {
84.         PImage image = loadImage(imageToLoad);
85.         if (image.width > MAX_IMAGE_WIDTH)
86.         {
87.           image.resize(MAX_IMAGE_WIDTH, image.height * MAX_IMAGE_WIDTH / image.width);
88.         }
89.         images.addFirst(image);
90.         if (images.size() > MAX_IMAGES)
91.         {
92.           images.removeLast();
93.         }
94.         imageToLoad = null;
95.       }
96.       delay(100);
97.     }
98.   }
99. }

wow !! cool stuff; I'll try to adapt it for my needs, really cool thing !
thanks again

Notice I didn't use a callback, after all. My program just iterate on the available images, and the loader just add a new one when finishing loading, and remove the oldest one to keep their number constant (once the queue has been filled).

Also my code has a weakness: if you request images faster than they are loaded, some requests can be lost. In this case, the requests should be queued as well. Again, it depends on your needs / case.

I try to understand how the image is displayed in your code, and don't really get it ;)
the image(image, pos, height / 2); seems to act like a buffer ? 5 images at the same time ?
this must be this part :

1.     for (PImage image : loader)
         {
           int pos = position - c++ * MAX_IMAGE_WIDTH;
           if (pos > width)
           {
             pos -= width;
           }
           image(image, pos, height / 2);
         }

right ?
for my final purpose, I would have need to display pictures according to their name…which would mean (I think) that I have to know the index of each file in the arraydeque
I try to get the content by index with:

1.  for (Iterator iter = loader.iterator();iter.hasNext();) {
    println(iter.next());
   

which gives me: processing.core.PImage@1a7789c
java.util.ArrayDeque$DeqIterator@1d709a5.
I don' t know how to use those values to make my five players image(…)- and then shaders after that…god…
I'll maybe consider to pay for someone to help me on this case, I'm pretty lost, completely beginner in java/processing.
thanks philo.

" I would have need to display pictures according to their name"
Ah? I haven't perceived this need in your description. In this case, perhaps the LinkedHashMap is more suited to your need, then. It is able to automatically deleted the eldest entry when you add a new one.

here's an attempt using linkedHashMap. It seems to load stuffs correctly, but the image is still blank…

1. import java.io.*;
   import java.util.*;
   String[] images;
   ImageLoader loader;
   int counter;
   int position;int MAX_IMAGES = 5;
   PImage image;
2. void setup()
   {
     size(1200, 400);
     imageMode(CENTER);
     String[] images = {
       "1.JPG", "2.JPG", "3.JPG", "4.JPG", "5.JPG", "6.JPG", "7.JPG", "8.JPG", "9.JPG", "10.JPG"
     };
   
     println(images);
     loader = new ImageLoader();
     loader.start();
     println("Starting");
   }
   
   
3. void draw()
   {
   
     background(255);
     int c = 0;
   
     if (image != null) {
       image(image, 0, height / 2, 400, 400);
     }
   }
   
   
   
4. void mousePressed()
   {
     counter %= 10;
     String path =String.valueOf(counter++)+".JPG";
     println("Loading " + path);
     loader.requestImage(path);
   }
   

in the 18 th line from bottom see pimage...... load image

thanks chrisir- now I would have need to find a way to make several image players to display files which are into the ram.