Elaborazione immagini e tempistica

[jumborex]

Dirò subito che la pagina di cui vorrei parlare, fondamentalmente funziona.
Tuttavia (un po' da sempre) mi trovo un problema di ritardi che non so bene come classificare, né tantomeno come risolvere.
L'idea è leggere un file immagine sul PC, spedirla al server magari ridimensionata e visualizzarla in ritorno alle dimensioni richieste.
Il codice mi pare discretamente semplice. Ecco una descrizione schematica:

<?
$immagine = '/images/immagine.jpg';
$absolut_immagine = realpath($immagine);
if ($_POST['loader']) {
if (! $_POST['altezza']) $altezza = 540; else $altezza = $_POST['altezza'];
// controllo che non ci siano stati errori nell'upload (codice = 0) 
if (! empty($_FILES['uploadfile']['tmp_name'])) {
 $load->load_image ($_FILES['uploadfile']['tmp_name'], $absolut_immagine, $altezza);
 }
} 
list($width, $height, $type, $attr) = getimagesize($absolut_immagine);
echo 'Dimensioni immagine: ' . $width . ' x ' . $height . '<br /><br />';
echo '<img src="' . $immagine . '" width="' . $display_width . '" height="' . $display_height . '" />';
?>
<form name="upload" method="post" action="" enctype="multipart/form-data">
<input type="hidden" name="loader" value="true"><br />
<label>Altezza immagine<br>
  <input type="text" name="altezza" value="540"></label>
<input type="file" name="uploadfile">
<input type="submit" name="go" value="Carica">
</form>

Resta da rivelare la sola funzione $load->load_image, che riporto qui, per chi avesse voglia di leggersela, e fin da adesso ringrazio:

class load_images {
public function load_image ($originale, $copia, $altezza = false, $larghezza = false) {
 list($width, $height, $type, $attr) = getimagesize($originale);
 if ((! $altezza) && (! $larghezza)) {
  $altezza = $height; }
 if (! $larghezza) {
  $larghezza = round($width * $altezza / $height);
  }
 if (! $altezza) {
  $altezza = round($height * $larghezza / $width);
 }
 if (! $reduced = imagecreatetruecolor($larghezza, $altezza)) die ('problema creazione nuova immagine');
 if (! $source = $this->get_img_resource($originale)) die ('errore su immagine sorgente');
 imagealphablending($reduced, false);              // per mantenere la trasparenza in PNG
 imagecopyresized($reduced, $source, 0, 0, 0, 0, $larghezza, $altezza, $width, $height);  // Salvo l'immagine (eventualmente) ridimensionata
 switch ($type) {
  case IMAGETYPE_GIF:
   imagegif($reduced, $copia);
   break;
  case IMAGETYPE_JPEG:
   imagejpeg($reduced, $copia, 85);
   break;
  case IMAGETYPE_PNG:
   imagesavealpha($reduced, true);
   imagepng($reduced, $copia, 0, PNG_NO_FILTER);
   break;
  default:
   die ('tipo immagine non supportato');
 return;
  }
 }

private function get_img_resource ($img_address) {
 list($width, $height, $type, $attr) = getimagesize($img_address);
 switch ($type) {
 case IMAGETYPE_GIF:
  return imagecreatefromgif ($img_address);
  break;
 case IMAGETYPE_JPEG:
  return imagecreatefromjpeg ($img_address);
  break;
 case IMAGETYPE_PNG:
  return imagecreatefrompng ($img_address);
  break;
 default:
  die ('tipo immagine non supportato');
 }
}
} 

Orbene, la domanda è questa:
come mai, data la struttura di cui sopra, qualche volta la pagina mi ritorna con l'immagine modificata, ma molto spesso no? Quasi sempre mi ricompare l'immagine vecchia e solo facendo un refresh della pagina mi appare la nuova immagine!
Che accidenti ci si può fare?
Sarò eternamente grato a chi saprà spiegarmi gli intimi recessi di questa gestione immagini!

[Shores]

Quel che sta succedendo deriva, con buona probabilità, dalla cache in scrittura su disco tipica di qualsiasi server.

Per capirci: il tuo codice riceve l'immagine, la decomprime in memoria (le funzioni GD sempre decomprimono una jpg prima di poterla manipolare), causando così un notevole uso di memoria, poi la ridimensiona, causando così un ulteriore uso di memoria poichè viene fatta una copia dell'immagine stessa, poi procede a salvarla su disco e ad inviare al browser il codice html che a sua volta, richiede l'immagine come ulteriore richiesta http al server web.

Il punto è proprio che tutto questo uso di memoria, nonchè il fatto che l'immagine debba poi essere riconvertita in jpg per esser salvata sul disco, fanno sicuramente si che il server decida di rimandare il vero e proprio salvataggio sul disco dell'immagine ridotta a quando la rapida sequenza di pesanti rischieste http sia finita...

Detto in altri termini, non c'è una vera soluzione a questo problema, perchè stai semplicemente chiedendo troppo al tuo server: devi invece fare in modo che in una pagina l'immagine venga caricata e ridimensionata e salvata, e in UN'ALTRA pagina venga mostrata la versione ridotta.

In questo modo potrai essere certo che tra una richiesta http e l'eltra il server avrà avuto il tempo di effettuare davvero il salvataggio della versione ridotta dell'immagine!

[jumborex]

[...] Detto in altri termini, non c'è una vera soluzione a questo problema, perchè stai semplicemente chiedendo troppo al tuo server [...]

Eh, hai espresso esattamente quello che io stesso temevo. La cosa strana è che in effetti il comportamento non è fisso: qualche volta fa il display giusto, qualche volta no!
Il display giusto, poi, è più frequente se usi il browser firefox, mai con IE 11. Qualche volta con altri browsers, come Chrome.
Comunque grazie.