Ciao a tutti,
sto cercando di realizzare un piccolo programma che mi permetta di visualizzare un'immagine (jpg) generata da uno script (chiamiamolo server) in c++ che lo preleva da una camera ccd e lo depositata ogni frazione di secondo in un file che si aggiorna continuamente.

Ho provato già con diverse funzioni in python, anche sfruttando pygame ma il problema è che talvolta lo script client legge l'immagine prima che questa sia stata scritta completamente dal server e si blocca dando un messaggio di formato immagine non valido.

questo l'ultimo script utilizzato:

import pygame
from pygame.locals import *
 
class App:
    def __init__(self):
        self._running = True
        self._display_surf = None
        self._image_surf = None
 
    def on_init(self):
        pygame.init()
        self._display_surf = pygame.display.set_mode((480,320), pygame.HWSURFACE)
        self._running = True
        self._image_surf = pygame.image.load("PHD2_currentimage.png").convert()
 
    def on_event(self, event):
        if event.type == QUIT:
            self._running = False
    def on_loop(self):
         self._image_surf = pygame.image.load("PHD2_currentimage.png").convert() <-- Rileggo l'immagine che nel frattempo lo script "server" ha riscritto
         
    def on_render(self):
        self._display_surf.blit(self._image_surf,(0,0))
        pygame.display.flip()
    
    def on_cleanup(self):
        pygame.quit()
 
    def on_execute(self):
        if self.on_init() == False:
            self._running = True
 
        while( self._running ):
            for event in pygame.event.get():
                self.on_event(event)
            self.on_loop()

            self.on_render()
        self.on_cleanup()

if __name__ == "__main__" :
    theApp = App()
    theApp.on_execute()

Lo script in c++ è modificabile anche se ci capisco gran poco.





PS

per velocizzare il processo di scrittura e lettura, utilizzo un filesystem di tipo ramfs su linux. (/var/lock/)

Il tempo di aggiornamento dell'immagine dipende dall'esposizione che il server applica alla camera ccd

Potresti fare una funzione on_load con la lettura del file protetta in un blocco try/except, che ritorna True se la lettura è andata a buon fine e False altrimenti. E nel ciclo principale qualcosa del genere:

if self.on_load():
    self.on_render()

Tra l'altro non è strettamente necessario fare una prima lettura nell'init dell'app.

Ottima Idea...ho provato e funziona inserendo questo codice:

 def on_loop(self):
       
            try:
                self._image_surf = pygame.image.load("PHD2_currentimage.png")
            except pygame.error, message:
                self.on_loop()
            self._image_surf.convert()
         

il problema è che nei log mi escono un sacco di errori del tipo:


libpng error: IDAT: CRC error

libpng warning: Ignoring bad adaptive filter type


perchè probabilmente riesce a leggerlo lo stesso anche se non è ancora stato scritto completamente...

ho provato anche ad implementare un controllo sul file per farlo leggere solo se chiuso... ma rimane sempre aperto a causa dell'elevata velocità di aggiornamento dell'immagine