Ho messo appunto un sistema di calcolo Width e Height dinamico... ma è performante?

[n0t]

..e può essere ottimizzato senza tutti questi cicli?

/*Le dimensioni massime per la thumb*/    
$maxWidth = 450;
$maxHeight = 300;

/*le dimensioni originali dell'immagine*/
$originalW = $this->getWidth();
$originalH = $this->getHeight();

/*se le dimensioni dell'immagini originali non superano le dimensioni massime che la thumb deve avere*/    
if( $originalW <= $maxWidth && $originalH <= $maxHeight )
{
    $profileTHBWidth = $originalW;
    $profileTHBHeight = $originalH;
}
/*se una delle 2 dimensioni supera le dimensioni massime*/
else if( $originalW > $maxWidth || $originalH > $maxHeight )
{
/*se supera la larghezza*/
    if($originalW > $maxWidth )
    {
/*il coefficienze % di rimpicciolimento a 1 cioè comincia dal 1% in meno*/
        $coeffW = 1;
        do 
        {
/*setto la larghezza della thumb con il coefficiente attuale*/
            $profileTHBWidth = $originalW-(($originalW*$coeffW)/100);
/*incremento il coefficiente*/
            ++$coeffW;
        } while( $profileTHBWidth > $maxWidth );
/*adesso calcolo l'altezza dell'immagine utilizzando il coefficiente trovato per la larghezza, perche se rimpicciolisco solo la larghezza viene non equilibrata l'immagine*/
        $prifileTHBHeight = $originalH-(($originalH*$coeffW)/100);
/*se nonostante il resizing l'altezza è sempre maggiore dispetto all'altezza massima*/
        if( $profileTHBHeight > $maxHeight )
        {
/*setto il coefficiente di resizing dell'altezza uguale a quello della larghezza*/
            $coeffH = $coeffW;
            do 
            {
/*calcolo le nuove dimensioni usando solo il coefficiente dell'altezza, visto che con quel coefficiente la larghezza e gia minore rispetto alla larghezza massima, però diminuendo ancora l'altezza devo continuare a ricalcolare la larghezza sempre per non far uscire l'immagine sgranata.. finche l'altezza massima non diventa minore o uguale all'altezza massima*/
                $profileTHBHeight = $originalH-(($originalH*$coeffH)/100);
                $profileTHBWidth = $originalW-(($originalW*$coeffH)/100);
                ++$coeffH;
            } while( $profileTHBHeight > $maxHeight );
        }
        else { /*va bene*/ }
    }
/*se la larghezza e minore al massimo consentito, mentre invece solo l'altezza esce dal massimo consentito*/
    else if( $originalH > $maxHeight && $originalW <= $maxWidth )
    {
/*coefficiente altezza a 1%*/
        $coeffH = 1;
        do 
        {
/*calcola le dimensioni tenendo sempre tutto equilibrato*/
            $profileTHBHeight = $originalH-(($originalH*$coeffH)/100);
                        $profileTHBWidth = $originalW-(($originalW*$coeffH)/100);
            ++$coeffH;
        } while( $profileTHBHeight > $maxHeight );
        $profileTHBWidth = $originalW-(($originalW*$coeffH)/100);
    }
} 

Ora è commentato xD

[filippo.toso]

Potresti spiegare a parole che cosa fa il codice che hai postato (così chi potrebbe volerti aiutare non deve fare un reverse engineering)?

[n0t]

Commentato xD

[n0t]

L'ho messa in una funzione stand-alone,

<?php

function getResized($w, $h)
{
    $maxWidth = 450;
    $maxHeight = 300;
    
    $originalW = $w;
    $originalH = $h;
     
    if( $originalW <= $maxWidth && $originalH <= $maxHeight )
    {
        $profileTHBWidth = $originalW;
        $profileTHBHeight = $originalH;
    }
    else if( $originalW > $maxWidth || $originalH > $maxHeight )
    {
        if($originalW > $maxWidth )
        {
            $coeffW = 1;
            print "COEFF W\n";
            do
            {
                print $coeffW."%\n";
                $profileTHBWidth = $originalW-(($originalW*$coeffW)/100);
                ++$coeffW;
            } while( $profileTHBWidth > $maxWidth );
            
            $profileTHBHeight = $originalH-(($originalH*$coeffW)/100);
            
            if( $profileTHBHeight > $maxHeight )
            {
                print "COEFF H\n";
                $coeffH = $coeffW;
                do
                {
                    print $coeffH."%\n";
                    $profileTHBHeight = $originalH-(($originalH*$coeffH)/100);
                    $profileTHBWidth = $originalW-(($originalW*$coeffH)/100);
                    ++$coeffH;
                } while( $profileTHBHeight > $maxHeight );
            }
            else { /*va bene*/ }
        }
        else if( $originalH > $maxHeight )
        {
            $coeffH = 1;
            do
            {
                $profileTHBHeight = $originalH-(($originalH*$coeffH)/100);
                $profileTHBWidth = $originalW-(($originalW*$coeffH)/100);
                ++$coeffH;
            } while( $profileTHBHeight > $maxHeight );
            $profileTHBWidth = $originalW-(($originalW*$coeffH)/100);
        }
    }
    return array($profileTHBWidth, $profileTHBHeight);
}

print_r(getResized(600, 700));
?>

[n0t]

Ah un grafico potrebbe darmi una dritta per le misure?
A Width 200pixel, quale sarebbe una buona Height equilibrata?

[n0t]

Alla fine, pensandoci bene, l'ho semplificato io xD

<?php

function getResized($w, $h)
{
    $maxWidth = 200;
    $maxHeight = 350;
    
    $originalW = $w;
    $originalH = $h;
     
    if( $originalW <= $maxWidth && $originalH <= $maxHeight )
    {
        $profileTHBWidth = $originalW;
        $profileTHBHeight = $originalH;
    }
    else if( $originalW > $maxWidth || $originalH > $maxHeight )
    {
        $coeff = 1;
        do
        {
            $profileTHBWidth = $originalW-(($originalW*$coeff)/100);
            $profileTHBHeight = $originalH-(($originalH*$coeff)/100);
            ++$coeff;
        } while( ($profileTHBWidth > $maxWidth) OR ($profileTHBHeight > $maxHeight) );
    }
    else { /*va bene*/ }

    return array(ceil($profileTHBWidth), ceil($profileTHBHeight));
}

print_r(getResized(5000, 2500));
?>

[filippo.toso]

Mah, non vedo il motivo di utilizzare dei cicli per eseguire delle semplici operazioni matematiche:

<?php 

function constrain(&$width, &$height, $maxwidth = false, $maxheight = false, $round = true) {

    $maxwidth  = $maxwidth  === false ? $width  : $maxwidth;
    $maxheight = $maxheight === false ? $height : $maxheight;

    $wscale = $width  / $maxwidth;
    $hscale = $height / $maxheight;
    
    if ($wscale > $hscale) {
        $height = $height * $maxwidth / $width; 
        $width  = $maxwidth;    
    } else {
        $width  = $width * $maxheight / $height; 
        $height = $maxheight;    
    }
    
    $width  = $round ? round($width)  : $width;
    $height = $round ? round($height) : $height;

}

function offset($width, $height, $maxwidth, $maxheight) {
    
    $left  = round(($maxwidth - $width) / 2);
    $right = $maxwidth - $width - $left;
    
    $top  = round(($maxheight - $height) / 2);
    $bottom = $maxheight - $height - $top;
    
    return array('left' => $left, 'right'  => $right, 
                 'top'  => $top,  'bottom' => $bottom);
                 
}

$width  = 300;
$height = 200;

$maxwidth  = 100;
$maxheight = 100;

constrain($width, $height, $maxwidth, $maxheight);

print($width . ' ' . $height);

$offset = offset($width, $height, $maxwidth, $maxheight);

print('<pre>');
print_r($offset);
print('</pre>');

?>

[n0t]

Originariamente inviato da filippo.toso
Mah, non vedo il motivo di utilizzare dei cicli per eseguire delle semplici operazioni matematiche:

<?php 

function constrain(&$width, &$height, $maxwidth = false, $maxheight = false, $round = true) {

    $maxwidth  = $maxwidth  === false ? $width  : $maxwidth;
    $maxheight = $maxheight === false ? $height : $maxheight;

    $wscale = $width  / $maxwidth;
    $hscale = $height / $maxheight;
    
    if ($wscale > $hscale) {
        $height = $height * $maxwidth / $width; 
        $width  = $maxwidth;    
    } else {
        $width  = $width * $maxheight / $height; 
        $height = $maxheight;    
    }
    
    $width  = $round ? round($width)  : $width;
    $height = $round ? round($height) : $height;

}

function offset($width, $height, $maxwidth, $maxheight) {
    
    $left  = round(($maxwidth - $width) / 2);
    $right = $maxwidth - $width - $left;
    
    $top  = round(($maxheight - $height) / 2);
    $bottom = $maxheight - $height - $top;
    
    return array('left' => $left, 'right'  => $right, 
                 'top'  => $top,  'bottom' => $bottom);
                 
}

$width  = 300;
$height = 200;

$maxwidth  = 100;
$maxheight = 100;

constrain($width, $height, $maxwidth, $maxheight);

print($width . ' ' . $height);

$offset = offset($width, $height, $maxwidth, $maxheight);

print('<pre>');
print_r($offset);
print('</pre>');

?>

Mh Mh Mh.. bella O_o