[ex³]

Ich mache ein paar Aktionen mit Fotos (drehen, Helligkeit, etc.) wenn ich nun ein Foto (was ein Dau hochlädt) mit an die 2000px drehe bekomme ich wie zu erwarten einen memory allocation error, eben das zu wenig Speicher vorhanden ist. Ich würde diese Fatal Error der beispielsweise bei imagerotate() auftreten kann abfangen. Leider hab ich schon einiges Versucht. Das Script bricht einfach ab. Auch mit @imagerotate bekomme ich nichts zurückgeliefert. Am liebsten wär mir ein false (wenn der speicher nicht reicht) um damit eine exception zu werfen.

Hat jemand eine Idee wie ich aus diesem FatalError eine Exception bekomme oder irgendwas anderes brauchbares statt einer leeren Seite?

[Bleistift]

Vorher prüfen wie gross das Bild ist?

[Jann Hendrik]

Wieviel Speicher verbraucht wird sollte sich in etwa doch errechnen lassen, oder?

Dazu auch:
http://www.developers-guide.net/foru...-grosse-bilder

wie groß ein Bild ist kann man ja mittels getimagesize ermitteln. Somit auch den Speicherberbrauch, oder?

[ex³]

Den benötigten Speicher zu berechnen, dachte ich auch schon allerdings war mir nich ganz klar wie das geht.

Wie berechne ich vorher den Speicherverbrauch? Eignet sich hierfür das Grundlagen Tutorial? Ich müsste das doch noch mit dem normalen Speicherverbrauch verrechnen oder?

Übrigens ist mir zum Beispiel aufgefallen das nicht unbedingt die Dateigröße entscheidend ist sondern auch die Bildmaße. So hat ein Bild mit 800kb und ca 2500*2000 Pixel einen Fatal Error erzeugt aber ein kleineres Bild mit größerer Dateigröße nicht.

[Jann Hendrik]

Zitat von ex³

Übrigens ist mir zum Beispiel aufgefallen das nicht unbedingt die Dateigröße entscheidend ist sondern auch die Bildmaße. So hat ein Bild mit 800kb und ca 2500*2000 Pixel einen Fatal Error erzeugt aber ein kleineres Bild mit größerer Dateigröße nicht.

Die Antwort auf diese Frage steht in dem link!

Zitat von ex³

Eignet sich hierfür das Grundlagen Tutorial?

ja!

[CIX88]

Wobei ich diesen Beitrag noch etwas ändern muss.

Nur für das laden vom 2500*2000 Pixel Bild gehen schon über 23MB drauf.
Dann kommen noch Kopien vom Bild hinzu, und du hast das Ende erreicht.

[ex³]

Ich hab im Web mal die gleiche Fehlermeldung aufgeschnappt

Fatal error: Allowed memory size of 16777216 bytes exhausted (tried to allocate 12 bytes)

Kann ich dadurch feststellen wieviel Speicher die Bildverarbeitung letztendlich verbraucht um zu vergleichen ob meine vorherige Berechnung auf das gleiche Ergebnis kommt?

Zu dem Fatal Error: Wieviel Speicher braucht den dieser Befehl der den Fatal Error erzeugt hat? 16777216 Bytes + 12 Bytes? Oder was bedeutet denn "tried to allocate..."?

[CIX88]

Die Seite ist noch nicht schön, aber:
http://www.mediacix.de/code/GDlib-un...f-85-code.html

Mit memory_get_usage() kannst du das sogar live auslesen.
Natürlich kann man auch im Vorfeld das ganze grob berechnen.

MB =

2500 * 2000 * 40
-----------------
8 * 1024 * 1024

Laut Fehlermeldung stehen nur 16MB (memory_limit) bereit, dein Bild braucht aber über 23MB und weil dies etwas mehr ist, kommt es zur Fehlermeldung.
Also der Versuch mehr als 16MB zu benutzen

[ex³]

Wie ich geschrieben habe ist die Meldung aus dem Web und nicht von mir. Auf meinem localhost ist die Meldung genauso formuliert nur die Werte sind anders.

Ok. Ich denke mit den Infos aus dem Thread werd ich mal ne Funktion bauen die den Speicher berechnet, wenn ich was aufgesetzt habe werde ich es hier mal posten.

EDIT: Hier ist nun meine Fehlermeldung. Bilddatei ist 2600*1200px groß und hat eine Dateigröße von 260,5 kb. Ich mache imagerotate um 2 Grad und dann kommt das:

Allowed memory size of 33554432 bytes exhausted (tried to allocate 6480 bytes) ...

Jetzt wo ich am Probieren gerade bin. Ich glaube das geht alles garnicht wie ich will. Ich kann vielleicht rauskriegen wieviel Speicher das Bilder braucht. Aber wieviel für imagerotate benötigt wird, kriege ich nicht raus.

[Basti]

Zitat von ex³

Jetzt wo ich am Probieren gerade bin. Ich glaube das geht alles garnicht wie ich will. Ich kann vielleicht rauskriegen wieviel Speicher das Bilder braucht. Aber wieviel für imagerotate benötigt wird, kriege ich nicht raus.

Schau dir mal die Funktion memory_get_peak_usage() an.

Ansonsten wurde ich einfach mal von der kleinstmöglichen Größe ausgehen und von dort an die Speicher-Grenze erhöhen, bis es passt. Mindestens brauchst du ja den momentan schon benutzten Speicher (memory_get_usage()), dazu den Bedarf für das „ausgepackte“ Original (also w * h + Farbtiefe) und den Bedarf für das Ergebnis. Hier musst du die Dimensionen eben anhand des Winkels der Drehung ausrechnen. Da noch ein bisschen Puffer für die Berechnung sollte wahrscheinlich reichen.

Basti

[Bleistift]

Einfach mal die Seite von Jann Hendrik beachten! Da wird das ganz geuna beschrieben. Es steht sogar, wie du die Grösse berechnen kannst...

[Jann Hendrik]

Zitat von Bleistift

Einfach mal die Seite von Jann Hendrik beachten! Da wird das ganz geuna beschrieben. Es steht sogar, wie du die Grösse berechnen kannst...

ja, das schon, aber der Speicher für die Bearbeitung muss noch berücksichtigt werden!
Denn die Verarbeitungsschritte verbrauchen ja auch noch was!

[Bleistift]

Zitat von Jann Hendrik

Denn die Verarbeitungsschritte verbrauchen ja auch noch was!

Das findet man vermutlich am besten mit Versuchen heraus: Ich behaupte einfach mal, dass das prozentmässig immer ungefähr gleich viel ist

[CIX88]

Aber wieviel für imagerotate benötigt wird, kriege ich nicht raus.

Kann man auch nicht wirklich berechnen, nur ungefähr abschätzen.

ImageRotate erzeugt innerhalb der GDlib ein neues TrueColor-Bild (gdImageTrueColor). Dabei wird von jedem Pixel R, G, B (als TrueColor) und Alpha vom Originalbild erfasst, die neue Postion berechnet und in das neue erzeugte Bild geschrieben. Man kann also davaon ausgehen, dass sich der Speicherbedarf mind. verdoppelt, weil sich in diesem Moment praktisch 2 Bilder im Speicher befinden. Jedenfalls solange bis der Bearbeitungsprozess beendet ist.

Hier hab ich mal versucht eine eigene Rotate-Funktion zu schreiben:
http://www.mediacix.de/code/demo.php5?id=165
Im Prinzip kommt das selbe raus, und der Speicherbedarf wird sogar noch größer, weil durch die Drehung das Bild in der Breite und Höhe auch größer wird. Jedenfalls größer als wenn das Bild nur um 90° gedreht wäre.

[ex³]

Im Prinzip kommt das selbe raus, und der Speicherbedarf wird sogar noch größer, weil durch die Drehung das Bild in der Breite und Höhe auch größer wird. Jedenfalls größer als wenn das Bild nur um 90° gedreht wäre.

Ja das stimmt. Der Fatal Error Fehler kommt nur bei einer Drehung zwischen 1-10 Grad, bei 90 oder 180 Grad funktioniert alles.

Hat sich also erledigt. Für mich lohnt sich der Aufwand nicht so eine Vorausberechnung zu machen.

[Pierre]

[quote=ex³;58996]

Der Fatal Error Fehler kommt nur bei einer Drehung zwischen 1-10 Grad, bei 90 oder 180 Grad funktioniert alles.

Hat sich also erledigt. Für mich lohnt sich der Aufwand nicht so eine Vorausberechnung zu machen.

Bei einer Drehung von 90 Grad (oder 90 multiples), php (gd) braucht braucht zwei mal mehr Memory als das original Bild (1000x900 pixels == 900x1000 pixels). Sobald du nur ein Grad mehr brauchst, dann das Bild wird breiter und höher, logisch

[CIX88]

Sobald du nur ein Grad mehr brauchst, dann das Bild wird breiter und höher, logisch

Jo was bereits erwähnt wurde

[Basti]

Unten ein Code zum Rumspielen und eine Beispielausgabe. Er enthält u.A. eine Berechnung der neuen Bild-Maße (oh man, Geometrie-Unterricht ist lange her, aber scheint zu stimmen ).

Was mich wundert, ist, dass die Bilder einiges mehr als das 4-fache (TrueColor + Alphakanal = 32 bit = 4 Byte) ihrer Breite * Höhe an Bytes benötigen. Ich hab den Faktor 5,6 gewählt. Er lag tatsächlich manchmal über 5,5.

Die so errechneten Werte der beiden Bilder hab ich dann zusammen mit 1,7 multipliziert und damit bei meinen Tests immer im grünen Bereich geblieben.

Aber vielleicht hab ihr bessere Werte, eine passendere Berechnung oder findet einen Fehler.

Basti

Drehungen um 90, 180 etc. Grad sind hier (noch) nicht berücksichtigt. Sie benötigen wesentlich weniger Speicher.

PHP-Code:

<pre><?php


// config

ini_set('memory_limit', '14m');

$iWidth  = 900;
$iHeight = 500;
$fAngle  = 45.0;
$fConfigImageFactor    = 5.6;
$fConfigRotationFactor = 1.7;


// calculate target dimensions

list ($iExpectedWidth, $iExpectedHeight) = calculateRotatedImageDimensions($iWidth, $iHeight, $fAngle);


// calculate expected memory usage

$iExpectedMemOriginal = $iWidth * $iHeight * $fConfigImageFactor;
$iExpectedMemRotated  = $iExpectedWidth * $iExpectedHeight * $fConfigImageFactor;

$iExpectedMemBoth = $iExpectedMemOriginal + $iExpectedMemRotated;
$iExpectedMem     = $iExpectedMemBoth * $fConfigRotationFactor;


// print configuration

printLine('dims original', "$iWidth * $iHeight");
printLine('angle', $fAngle);
printLine('image mem factor', $fConfigImageFactor);
printLine('rotation factor', $fConfigRotationFactor);
printLine();


// memory limit

$iMemLimit = getMemLimit();
printLine('memory limit', $iMemLimit, 'formatNumber');


// expected result

// add actual (real) memory usage
$iExpectedMemTotal = getMemUsage($iExpectedMem, true);
printLine('expected total mem', $iExpectedMemTotal, 'formatNumber');

if (is_null($iMemLimit) || $iExpectedMemTotal <= $iMemLimit) {

    $sExpectedResult = 'okay';

} else {

    $sExpectedResult = 'Out of memory (almost)';
}
printLine('expected result', $sExpectedResult);
printLine();


// create and rotate image and print results

$iMemStart    = getMemUsage();
$rImgOriginal = imagecreatetruecolor($iWidth, $iHeight);
$iMemOriginal = getMemUsage(-$iMemStart);

printLine('mem used by original', $iMemOriginal, 'formatNumber');
printLine('expected', $iExpectedMemOriginal, 'formatNumber');
printLine();

$iMemTmp     = getMemUsage();
$rImgRotated = imagerotate($rImgOriginal, $fAngle, 0);
$iMemRotated = getMemUsage(-$iMemTmp);

printLine('mem used by rotated', $iMemRotated, 'formatNumber');
printLine('expected', $iExpectedMemRotated, 'formatNumber');
printLine();

printLine('mem usage total', memory_get_peak_usage(true) - $iMemStart, 'formatNumber');
printLine('expected', $iExpectedMemTotal, 'formatNumber');
printLine();


// print expected and real dimensions of rotated image
// (orientation ignored)

printLine('dims expected', "$iExpectedWidth * $iExpectedHeight");
printLine('real dims', imagesy($rImgRotated) . ' * ' . imagesx($rImgRotated));


// -----------
//  functions
// -----------


// orientation ignored

function calculateRotatedImageDimensions($iWidth, $iHeight, $fAngle)
{
    $fAngleRad = deg2rad($fAngle % 90);
    $fSin = sin($fAngleRad);
    $fCos = cos($fAngleRad);

    $iNewWidth  = ceil(($iWidth  * $fSin) + ($iHeight * $fCos));
    $iNewHeight = ceil(($iHeight * $fSin) + ($iWidth  * $fCos));

    return array($iNewWidth, $iNewHeight);
}

function printLine($sLabel = '', $mValue = null, $mCallback = null)
{
    if (!is_null($mCallback))
        $mValue = call_user_func($mCallback, $mValue);

    printf("%-20s %15s\n", $sLabel, (string) $mValue);
}

function getMemUsage($iOffset = 0, $bReal = false)
{
    return memory_get_usage($bReal) + $iOffset;
}

function getMemLimit()
{
    $mMemLimit = ini_get('memory_limit');

    if ($mMemLimit != -1)
        return getBytes($mMemLimit);
}

function getBytes($mValue) {

    $mValue = trim($mValue);
    
    if (is_numeric($mValue)) {

        $iValue = $mValue;
    
    } else {

        $sUnit  = strtolower(substr($mValue, -1));
        $iValue = (int) substr($mValue, 0, -1);
        
        switch ($sUnit) {
            case 'k':
                $iValue *= 1024;
            case 'm':
                $iValue *= 1024;
            case 'g':
                $iValue *= 1024;
        }
    }
    return $iValue;
}

function formatNumber($m)
{
    if (is_null($m))
        return '---';

    $i = round($m * 100) === round($m) * 100 ? 0 : 2;
    
    return number_format($m, $i, '.', ',');
}

Beispielausgabe:

dims original              900 * 500
angle                             45
image mem factor                 5.6
rotation factor                  1.7
                                    
memory limit              14,680,064
expected total mem        13,876,696
expected result                 okay
                                    
mem used by original       2,269,400
expected                   2,520,000
                                    
mem used by rotated        4,933,576
expected                   5,488,560
                                    
mem usage total           12,759,136
expected                  13,876,696
                                    
dims expected              990 * 990
real dims                  990 * 990

[MrNiceGuy]

Ich bin der Meinung - bevor man sich mit soetwas auseinandersetzen muss (Speicherknappheit im Script) - dass ein Script, welches Bilddaten verarbeiten soll ruhig genug Speicher zur Verfügung haben soll. Ich habe meinen Cron-Jobs meist 256 oder 512 MB zugestanden, damit eben das nicht passiert, was hier beschrieben wird!?

[Jann Hendrik]

Zitat von MrNiceGuy

Ich bin der Meinung [...] ruhig genug Speicher zur Verfügung haben soll.

Was aber heißt, dass man Zugriff auf die php.ini haben muss, was nicht jeder haben dürfte!
Oder lässt sich das als .httaccess-Direktive ändern?