imageView =new ImageView(this);
Bitmap bitmap=BitmapFactory.decodeResource(getResources(), R.drawable.anguria);
bitmap=Bitmap.createScaledBitmap(bitmap, 100, 100, false);
Log.v("LARGHEZZA DELLA BITMAP",""+bitmap.getWidth());
Log.v("ALTEZZA DELLA BITMAP",""+bitmap.getHeight());
imageView.setImageBitmap(bitmap);
mainLayout.addView(imageView);
}
@Override
public void onWindowFocusChanged(boolean hasFocus){
super.onWindowFocusChanged(hasFocus);
Log.v("LARGHEZZA DI IMAGEVIEW",""+imageView.getWidth());
Log.v("ALTEZZA DI IMAGEVIEW",""+imageView.getHeight());
}
04-18 15:59:10.215: V/LARGHEZZA DELLA BITMAP(6108): 100 04-18 15:59:10.216: V/ALTEZZA DELLA BITMAP(6108): 100 ..... 04-18 15:59:10.434: V/LARGHEZZA DI IMAGEVIEW(6108): 100 04-18 15:59:10.434: V/ALTEZZA DI IMAGEVIEW(6108): 100Ho ridotto l'immagine senza rispetto per le proporzioni.
Ma ricordo adesso che si può usare Matrix per scalare le immagini.
Ciò può essere molto utile, anziché calcolare il rapporto larghezza/altezza e agire di conseguenza...
Vediamo...
imageView =new ImageView(this);
Bitmap bitmap=BitmapFactory.decodeResource(getResources(), R.drawable.anguria);
Log.v("LARGHEZZA DELLA BITMAP",""+bitmap.getWidth());
Log.v("ALTEZZA DELLA BITMAP",""+bitmap.getHeight());
Matrix matrix=new Matrix();
matrix.postScale(.5f,.5f);
bitmap=Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
Log.v("LARGHEZZA DELLA BITMAP DOPO MATRIX",""+bitmap.getWidth());
Log.v("ALTEZZA DELLA BITMAP DOPO MATRIX",""+bitmap.getHeight());
imageView.setImageBitmap(bitmap);
mainLayout.addView(imageView);
}
@Override
public void onWindowFocusChanged(boolean hasFocus){
super.onWindowFocusChanged(hasFocus);
Log.v("LARGHEZZA DI IMAGEVIEW",""+imageView.getWidth());
Log.v("ALTEZZA DI IMAGEVIEW",""+imageView.getHeight());
}
04-18 19:01:38.411: V/LARGHEZZA DELLA BITMAP(6466): 408 04-18 19:01:38.411: V/ALTEZZA DELLA BITMAP(6466): 313 04-18 19:01:38.412: V/ALTEZZA DELLA BITMAP DOPO MATRIX(6466): 157 ..... 04-18 19:01:39.289: V/LARGHEZZA DI IMAGEVIEW(6466): 204 04-18 19:01:39.290: V/ALTEZZA DI IMAGEVIEW(6466): 157Perfetto! La bitmap si è ridimensionata e la ImageView con lei.
Ora voglio portare la bitmap a una larghezza di 100.
Calcolo il rapporto fra 100 e la larghezza della bitmap...
imageView =new ImageView(this);
Bitmap bitmap=BitmapFactory.decodeResource(getResources(), R.drawable.anguria);
Log.v("LARGHEZZA DELLA BITMAP",""+bitmap.getWidth());
Log.v("ALTEZZA DELLA BITMAP",""+bitmap.getHeight());
float Ratio=100f/(float)bitmap.getWidth();
Matrix matrix=new Matrix();
matrix.postScale(Ratio,Ratio);
bitmap=Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
Log.v("LARGHEZZA DELLA BITMAP DOPO MATRIX",""+bitmap.getWidth());
Log.v("ALTEZZA DELLA BITMAP DOPO MATRIX",""+bitmap.getHeight());
imageView.setImageBitmap(bitmap);
mainLayout.addView(imageView);
}
@Override
public void onWindowFocusChanged(boolean hasFocus){
super.onWindowFocusChanged(hasFocus);
Log.v("LARGHEZZA DI IMAGEVIEW",""+imageView.getWidth());
Log.v("ALTEZZA DI IMAGEVIEW",""+imageView.getHeight());
}
E vediamo le misure:
04-18 19:08:39.152: V/LARGHEZZA DELLA BITMAP(6512): 408 04-18 19:08:39.152: V/ALTEZZA DELLA BITMAP(6512): 313 04-18 19:08:39.153: V/LARGHEZZA DELLA BITMAP DOPO MATRIX(6512): 100 04-18 19:08:39.153: V/ALTEZZA DELLA BITMAP DOPO MATRIX(6512): 77 ..... 04-18 19:08:39.562: V/LARGHEZZA DI IMAGEVIEW(6512): 100 04-18 19:08:39.562: V/ALTEZZA DI IMAGEVIEW(6512): 77Perfetto! La larghezza è stata portata a 100!
Ora voglio che l'altezza sia pari a 100:
imageView =new ImageView(this);
Bitmap bitmap=BitmapFactory.decodeResource(getResources(), R.drawable.anguria);
Log.v("LARGHEZZA DELLA BITMAP",""+bitmap.getWidth());
Log.v("ALTEZZA DELLA BITMAP",""+bitmap.getHeight());
float Ratio=100f/(float)bitmap.getHeight();
Matrix matrix=new Matrix();
matrix.postScale(Ratio,Ratio);
bitmap=Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
Log.v("LARGHEZZA DELLA BITMAP DOPO MATRIX",""+bitmap.getWidth());
Log.v("ALTEZZA DELLA BITMAP DOPO MATRIX",""+bitmap.getHeight());
imageView.setImageBitmap(bitmap);
mainLayout.addView(imageView);
}
@Override
public void onWindowFocusChanged(boolean hasFocus){
super.onWindowFocusChanged(hasFocus);
Log.v("LARGHEZZA DI IMAGEVIEW",""+imageView.getWidth());
Log.v("ALTEZZA DI IMAGEVIEW",""+imageView.getHeight());
}
04-18 19:10:26.931: V/LARGHEZZA DELLA BITMAP(6601): 408 04-18 19:10:26.931: V/ALTEZZA DELLA BITMAP(6601): 313 04-18 19:10:26.937: V/LARGHEZZA DELLA BITMAP DOPO MATRIX(6601): 130 04-18 19:10:26.938: V/ALTEZZA DELLA BITMAP DOPO MATRIX(6601): 100 ..... 04-18 19:10:27.114: V/LARGHEZZA DI IMAGEVIEW(6601): 130 04-18 19:10:27.114: V/ALTEZZA DI IMAGEVIEW(6601): 100Perfetto!
Dunque, se un'immagine è orizzontale, la misura da riportare a 100 sarà la larghezza, mentre se è verticale la misura sarà l'altezza.
Potremo così costringere un'immagine a stare nei limiti che vogliamo.
Ma se ho un'immagine orizzontale, che riduco a 100 di larghezza ma voglio che non occupi più di una certa dimensione in altezza, ossia ho due limiti, come mi metto?
Se porto direttamente l'altezza a valori inferiori al limite verticale, potrei avere ancora una larghezza superiore a 100.
Se porto la larghezza a valori inferiori a 100 potrei avere ancora un'altezza superiore al secondo limite.
Così, per le immagini orizzontali bisogna prima rapportarle a 100 e poi al secondo limite.
Iniziamo a ridimensionare le immagini secondo la larghezza o l'altezza a seconda che siano rispettivamente orizzontali o verticali.
Facciamo conto che il limite orizzontale sia 100 e quello verticale di 50.
Innanzitutto distinguiamo se l'immagine è orizzontale o verticale. Se è perfettamente quadrata può rientrare nel campo di quelle verticali.
imageView =new ImageView(this);
Bitmap bitmap=BitmapFactory.decodeResource(getResources(), R.drawable.anguria);
Log.v("LARGHEZZA DELLA BITMAP",""+bitmap.getWidth());
Log.v("ALTEZZA DELLA BITMAP",""+bitmap.getHeight());
int larghezza=bitmap.getWidth();
int altezza=bitmap.getHeight();
float Ratio;
if(altezza>=larghezza) Ratio=50f/(float)bitmap.getHeight();
else Ratio=100f/(float)bitmap.getWidth();
Matrix matrix=new Matrix();
matrix.postScale(Ratio,Ratio);
bitmap=Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
Log.v("LARGHEZZA DELLA BITMAP DOPO MATRIX",""+bitmap.getWidth());
Log.v("ALTEZZA DELLA BITMAP DOPO MATRIX",""+bitmap.getHeight());
imageView.setImageBitmap(bitmap);
mainLayout.addView(imageView);
}
@Override
public void onWindowFocusChanged(boolean hasFocus){
super.onWindowFocusChanged(hasFocus);
Log.v("LARGHEZZA DI IMAGEVIEW",""+imageView.getWidth());
Log.v("ALTEZZA DI IMAGEVIEW",""+imageView.getHeight());
}
Ecco: questo codice stabilisce un limite di larghezza 100 per le immagini orizzontali, mentre stabilisce un limite di altezza 50 per le immagini verticali e quadrate.Lo provo dapprima con l'immagine orizzontale "anguria", quindi con l'immagine verticale "torre": Con "anguria", immagine orizzontale:
04-18 19:26:51.062: V/LARGHEZZA DELLA BITMAP(6785): 408 04-18 19:26:51.062: V/ALTEZZA DELLA BITMAP(6785): 313 04-18 19:26:51.062: V/LARGHEZZA DELLA BITMAP DOPO MATRIX(6785): 100 04-18 19:26:51.062: V/ALTEZZA DELLA BITMAP DOPO MATRIX(6785): 77 04-18 19:26:51.255: V/LARGHEZZA DI IMAGEVIEW(6785): 100 04-18 19:26:51.255: V/ALTEZZA DI IMAGEVIEW(6785): 77Mi ha ridotto l'immagine orizzontale a una larghezza di 100 (con un'altezza di 77).
Con "torre", immagine verticale:
04-18 19:29:13.569: V/LARGHEZZA DELLA BITMAP(6832): 591 04-18 19:29:13.570: V/ALTEZZA DELLA BITMAP(6832): 888 04-18 19:29:13.570: V/LARGHEZZA DELLA BITMAP DOPO MATRIX(6832): 33 04-18 19:29:13.570: V/ALTEZZA DELLA BITMAP DOPO MATRIX(6832): 50 04-18 19:29:13.769: V/LARGHEZZA DI IMAGEVIEW(6832): 33 04-18 19:29:13.770: V/ALTEZZA DI IMAGEVIEW(6832): 50Mi ha ridotto l'immagine verticale a un'altezza di 50 (con larghezza pari a 33).
Ora, però, io voglio che per l'immagine orizzontale anche l'altezza abbia dei limiti, ossia che sia al massimo di 50.
Come fare?
Proviamo...
layout=new RelativeLayout(this);
BitmapDrawable sfondo=(BitmapDrawable)this.getResources().getDrawable(R.drawable.cartellanuova);
layout.setBackground(sfondo);
//settaggio dei parametri
LayoutParams lParams=new LayoutParams(LayWidth,LayHeight);
lParams.leftMargin=LayLeft;
lParams.topMargin=LayTop;
layout.setLayoutParams(lParams);
//CREAZIONE DELL'IMMAGINE
imageView =new ImageView(this);
Bitmap bitmap=BitmapFactory.decodeResource(getResources(), R.drawable.anguria);
Log.v("LARGHEZZA DELLA BITMAP",""+bitmap.getWidth());
Log.v("ALTEZZA DELLA BITMAP",""+bitmap.getHeight());
int larghezza=bitmap.getWidth();
int altezza=bitmap.getHeight();
float Ratio;
if(altezza>=larghezza) Ratio=50f/(float)bitmap.getHeight();
else Ratio=100f/(float)bitmap.getWidth();
Matrix matrix=new Matrix();
matrix.postScale(Ratio,Ratio);
bitmap=Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
Log.v("LARGHEZZA DELLA BITMAP DOPO MATRIX",""+bitmap.getWidth());
Log.v("ALTEZZA DELLA BITMAP DOPO MATRIX",""+bitmap.getHeight());
if(bitmap.getHeight()>50){
Ratio=50f/(float)bitmap.getHeight();
Log.v("RATIO",""+Ratio);
matrix=new Matrix();
matrix.postScale(Ratio, Ratio);
bitmap=Bitmap.createBitmap(bitmap,0,0,bitmap.getWidth(), bitmap.getHeight(),matrix,false);
Log.v("LARGHEZZA DELLA BITMAP DOPO SECONDA MATRIX",""+bitmap.getWidth());
Log.v("ALTEZZA DELLA BITMAP DOPO SECONDA MATRIX",""+bitmap.getHeight());
}
imageView.setImageBitmap(bitmap);
mainLayout.addView(imageView);
}
@Override
public void onWindowFocusChanged(boolean hasFocus){
super.onWindowFocusChanged(hasFocus);
Log.v("LARGHEZZA DI IMAGEVIEW",""+imageView.getWidth());
Log.v("ALTEZZA DI IMAGEVIEW",""+imageView.getHeight());
}
Ecco.La provo con l'immagine anguria che è orizzontale con poca differenza fra altezza e larghezza:
04-18 20:05:06.598: V/LARGHEZZA DELLA BITMAP(7254): 408 04-18 20:05:06.598: V/ALTEZZA DELLA BITMAP(7254): 313 04-18 20:05:06.598: V/LARGHEZZA DELLA BITMAP DOPO MATRIX(7254): 100 04-18 20:05:06.598: V/ALTEZZA DELLA BITMAP DOPO MATRIX(7254): 77 04-18 20:05:06.600: V/RATIO(7254): 0.64935064 04-18 20:05:06.603: V/LARGHEZZA DELLA BITMAP DOPO SECONDA MATRIX(7254): 65 04-18 20:05:06.604: V/ALTEZZA DELLA BITMAP DOPO SECONDA MATRIX(7254): 50Dopo aver ridotto l'immagine orizzontale a 100, questa ha un'altezza di 77, che è eccessiva rispetto al limite verticale di 50. Calcola nuovamente il rapporto e la riduce ulteriormente fino a un'altezza di 50.
La provo adesso con l'immagine torre che è verticale:
04-18 20:07:41.595: V/LARGHEZZA DELLA BITMAP(7302): 591 04-18 20:07:41.595: V/ALTEZZA DELLA BITMAP(7302): 888 04-18 20:07:41.596: V/LARGHEZZA DELLA BITMAP DOPO MATRIX(7302): 33 04-18 20:07:41.596: V/ALTEZZA DELLA BITMAP DOPO MATRIX(7302): 50 04-18 20:07:41.726: V/LARGHEZZA DI IMAGEVIEW(7302): 33 04-18 20:07:41.726: V/ALTEZZA DI IMAGEVIEW(7302): 50Non va oltre la prima riduzione all'altezza di 50.
La provo adesso con l'immagine chiave che è orizzontale più stretta della precedente orizzontale:
04-18 20:09:23.188: V/LARGHEZZA DELLA BITMAP(7348): 406 04-18 20:09:23.188: V/ALTEZZA DELLA BITMAP(7348): 175 04-18 20:09:23.188: V/LARGHEZZA DELLA BITMAP DOPO MATRIX(7348): 100 04-18 20:09:23.193: V/ALTEZZA DELLA BITMAP DOPO MATRIX(7348): 43 04-18 20:09:23.401: V/LARGHEZZA DI IMAGEVIEW(7348): 100 04-18 20:09:23.402: V/ALTEZZA DI IMAGEVIEW(7348): 43In questo caso, con la riduzione a 100 l'altezza è già sotto il limite verticale di 50 e quindi l'immagine non necessita di ulteriori riduzioni.
Tutto ciò è quanto era nelle mie intenzioni!
Adesso bisogna studiare il posizionamento delle immagini in una View, in relazione al rapporto con una TextView.
Nessun commento:
Posta un commento