Immagine di scimmia
Mantieni tutto organizzato con le raccolte
Salva e classifica i contenuti in base alle tue preferenze.
Una classe monkeyrunner per contenere un'immagine dello schermo del dispositivo o dell'emulatore. L'immagine è
copiati dal buffer dello schermo durante uno screenshot. I metodi di questo oggetto ti consentono
convertire l'immagine in vari formati di archiviazione, scrivere l'immagine in un file, copiare parti
l'immagine e confronta questo oggetto con altri oggetti MonkeyImage.
Non è necessario creare nuove istanze di MonkeyImage. Utilizza invece
MonkeyDevice.takeSnapshot() per creare una nuova istanza da uno screenshot. Ad esempio, utilizza:
newimage = MonkeyDevice.takeSnapshot()
Riepilogo
| Metodi |
|
stringa
|
convertToBytes.
(formato stringa)
Converte l'immagine corrente in un formato particolare e la restituisce come
string a cui potrai accedere come iterabile di byte binari.
|
|
tupla
|
getRawPixel
(numero intero x,
numero intero y)
Restituisce il singolo pixel nella posizione dell'immagine (x,y), come
una tupla di numero intero, nel formato (a,r,g,b).
|
|
numero intero
|
getRawPixelInt
(numero intero x,
numero intero y)
Restituisce il singolo pixel nella posizione dell'immagine (x,y), come
un numero intero a 32 bit.
|
MonkeyImage
|
getSubImage
(rettangolo a forma di tupla)
Crea un nuovo oggetto MonkeyImage da una selezione rettangolare di
l'immagine corrente.
|
|
booleano
|
sameAs
(MonkeyImage)
altri
percentuale in virgola mobile)
Confronta questo oggetto MonkeyImage con un altro e restituisce il risultato di
il confronto. L'argomento percent specifica la percentuale
differenza che consente alle due immagini di essere "uguali".
|
|
void
|
writeToFile
(percorso stringa,
formato stringa)
Scrive l'immagine corrente nel file specificato da filename, nel
specificato da format.
|
Metodi pubblici
Converte l'immagine corrente in un formato particolare e la restituisce come string
a cui potrai accedere come iterabili di byte binari.
Argomenti
| formato |
Il formato di output desiderato. Sono supportati tutti i comuni formati di output raster.
Il valore predefinito è "png" (Portable Network Graphics).
|
tupla
getRawPixel
(numero intero x,
intero y)
Restituisce il singolo pixel nella posizione dell'immagine (x,y), come
una tupla di numero intero, nel formato (a,r,g,b).
Argomenti
| x |
La posizione orizzontale del pixel, che inizia con 0 a sinistra dello schermo nella
l'orientamento che aveva al momento dell'acquisizione dello screenshot.
|
| y |
La posizione verticale del pixel, che inizia con 0 nella parte superiore dello schermo nella
l'orientamento che aveva al momento dell'acquisizione dello screenshot.
|
Ritorni
-
Una tupla di numeri interi che rappresentano il pixel, nel formato (a,r,g,b) dove
a è il valore del canale alfa, mentre r, g e b sono i valori rosso, verde e blu,
rispettivamente.
tupla
getRawPixelInt
(numero intero x,
intero y)
Restituisce il singolo pixel nella posizione dell'immagine (x,y), come
un numero intero. Usa questo metodo per risparmiare sulla memoria.
Argomenti
| x |
La posizione orizzontale del pixel, che inizia con 0 a sinistra dello schermo nella
l'orientamento che aveva al momento dell'acquisizione dello screenshot.
|
| y |
La posizione verticale del pixel, che inizia con 0 nella parte superiore dello schermo nella
l'orientamento che aveva al momento dell'acquisizione dello screenshot.
|
Ritorni
-
I valori a, r, g e b del pixel come valori a 8 bit combinati in un intervallo a 32 bit
intero, con a come 8 bit più a sinistra, r il successivo più a destra e così via.
MonkeyImage
getSubImage
(rettangolo a forma di tupla)
Crea un nuovo oggetto MonkeyImage da una selezione rettangolare di
l'immagine corrente.
Argomenti
| rect |
Una tupla (x, y, w, h) che specifica la selezione. x e y specificano il pixel in base 0
dell'angolo in alto a sinistra della selezione. w specifica la larghezza
regione, mentre h specifica la sua altezza, entrambe espresse in pixel.
L'orientamento dell'immagine è uguale all'orientamento dello schermo del momento in cui
screenshot.
|
Ritorni
-
Un nuovo oggetto
MonkeyImage contenente la selezione.
booleano
sameAs
(
MonkeyImage
altra immagine,
Percentuale in virgola mobile
)
Confronta questo oggetto MonkeyImage con un altro e restituisce il risultato di
il confronto. L'argomento percent specifica la percentuale
differenza che consente alle due immagini di essere "uguali".
Argomenti
| altro |
Un altro oggetto MonkeyImage da confrontare con questo.
|
|
percentuale
|
Un numero in virgola mobile compreso tra 0,0 e 1,0 inclusi, che indica
la percentuale di pixel che devono essere uguali affinché il metodo restituisca
true. Il valore predefinito è 1, 0 e indica che tutti i pixel
devono corrispondere.
|
Ritorni
-
Valore booleano
true se le immagini corrispondono, oppure booleano false in caso contrario.
Scrive l'immagine corrente nel file specificato da filename, nel
specificato da format.
Argomenti
| percorso |
Il nome file completo e l'estensione del file di output.
|
|
formato
|
Il formato di output da utilizzare per il file. Se non viene fornito alcun formato,
tenta di indovinare il formato dall'estensione del nome file. In caso contrario
viene specificata l'estensione e non viene specificato alcun formato, viene quindi utilizzato il formato predefinito
"png" (Portable Network Graphics).
|
I campioni di contenuti e codice in questa pagina sono soggetti alle licenze descritte nella Licenza per i contenuti. Java e OpenJDK sono marchi o marchi registrati di Oracle e/o delle sue società consociate.
Ultimo aggiornamento 2025-07-27 UTC.
[null,null,["Ultimo aggiornamento 2025-07-27 UTC."],[],[],null,["# MonkeyImage\n\nA monkeyrunner class to hold an image of the device or emulator's screen. The image is\ncopied from the screen buffer during a screenshot. This object's methods allow you to\nconvert the image into various storage formats, write the image to a file, copy parts of\nthe image, and compare this object to other `MonkeyImage` objects.\n\n\nYou do not need to create new instances of `MonkeyImage`. Instead, use\n[MonkeyDevice.takeSnapshot()](/tools/help/MonkeyDevice#takeSnapshot) to create a new instance from a screenshot. For example, use: \n\n```\nnewimage = MonkeyDevice.takeSnapshot()\n```\n\nSummary\n-------\n\n| Methods ||||||||||||\n|----------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---|---|---|---|---|---|---|---|---|---|\n| *string* | [convertToBytes](#convertToBytes) (*string* format) Converts the current image to a particular format and returns it as a *string* that you can then access as an *iterable* of binary bytes. |\n| *tuple* | [getRawPixel](#getRawPixel) (*integer* x, *integer* y) Returns the single pixel at the image location (x,y), as an a *tuple* of *integer*, in the form (a,r,g,b). |\n| *integer* | [getRawPixelInt](#getRawPixelInt) (*integer* x, *integer* y) Returns the single pixel at the image location (x,y), as a 32-bit *integer*. |\n| ` `[MonkeyImage](/tools/help/MonkeyImage)` ` | [getSubImage](#getSubImage) (*tuple* rect) Creates a new `MonkeyImage` object from a rectangular selection of the current image. |\n| *boolean* | [sameAs](#sameAs) ([MonkeyImage](/tools/help/MonkeyImage) other, *float* percent) Compares this `MonkeyImage` object to another and returns the result of the comparison. The `percent` argument specifies the percentage difference that is allowed for the two images to be \"equal\". |\n| *void* | [writeToFile](#writeToFile) (*string* path, *string* format) Writes the current image to the file specified by `filename`, in the format specified by `format`. |\n\nPublic methods\n--------------\n\n#### *string*\nconvertToBytes\n( *string* format)\n\n\nConverts the current image to a particular format and returns it as a *string*\nthat you can then access as an *iterable* of binary bytes. \n\n##### Arguments\n\n| format | The desired output format. All of the common raster output formats are supported. The default value is \"png\" (Portable Network Graphics). |\n|--------|-------------------------------------------------------------------------------------------------------------------------------------------|\n\n#### *tuple*\ngetRawPixel\n(*integer* x, *integer* y)\n\n\nReturns the single pixel at the image location (x,y), as an\na *tuple* of *integer*, in the form (a,r,g,b). \n\n##### Arguments\n\n| x | The horizontal position of the pixel, starting with 0 at the left of the screen in the orientation it had when the screenshot was taken. |\n| y | The vertical position of the pixel, starting with 0 at the top of the screen in the orientation it had when the screenshot was taken. |\n|---|------------------------------------------------------------------------------------------------------------------------------------------|\n\n##### Returns\n\n- A tuple of integers representing the pixel, in the form (a,r,g,b) where a is the alpha channel value, and r, g, and b are the red, green, and blue values, respectively. \n\n#### *tuple*\ngetRawPixelInt\n(*integer* x, *integer* y)\n\n\nReturns the single pixel at the image location (x,y), as an\nan *integer*. Use this method to economize on memory. \n\n##### Arguments\n\n| x | The horizontal position of the pixel, starting with 0 at the left of the screen in the orientation it had when the screenshot was taken. |\n| y | The vertical position of the pixel, starting with 0 at the top of the screen in the orientation it had when the screenshot was taken. |\n|---|------------------------------------------------------------------------------------------------------------------------------------------|\n\n##### Returns\n\n- The a,r,g, and b values of the pixel as 8-bit values combined into a 32-bit integer, with a as the leftmost 8 bits, r the next rightmost, and so forth. \n\n#### `\n`[MonkeyImage](/tools/help/MonkeyImage)`\n`\ngetSubImage\n(*tuple* rect)\n\n\nCreates a new `MonkeyImage` object from a rectangular selection of the\ncurrent image. \n\n##### Arguments\n\n| rect | A tuple (x, y, w, h) specifying the selection. x and y specify the 0-based pixel position of the upper left-hand corner of the selection. w specifies the width of the region, and h specifies its height, both in units of pixels. The image's orientation is the same as the screen orientation at the time the screenshot was made. |\n|------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n\n##### Returns\n\n- A new `MonkeyImage` object containing the selection. \n\n#### *boolean*\nsameAs\n( `\n`[MonkeyImage](/tools/help/MonkeyImage)`\n` otherImage, *float* percent )\n\n\nCompares this `MonkeyImage` object to another and returns the result of\nthe comparison. The `percent` argument specifies the percentage\ndifference that is allowed for the two images to be \"equal\". \n\n##### Arguments\n\n| other | Another `MonkeyImage` object to compare to this one. |\n| percent | A float in the range 0.0 to 1.0, inclusive, indicating the percentage of pixels that need to be the same for the method to return `true`. The default is 1.0, indicating that all the pixels must match. |\n|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n\n##### Returns\n\n- Boolean `true` if the images match, or boolean `false` otherwise. \n\n#### void\nwriteToFile\n(*string* filename, *string* format)\n\n\nWrites the current image to the file specified by `filename`, in the\nformat specified by `format`. \n\n##### Arguments\n\n| path | The fully-qualified filename and extension of the output file. |\n| format | The output format to use for the file. If no format is provided, then the method tries to guess the format from the filename's extension. If no extension is provided and no format is specified, then the default format of \"png\" (Portable Network Graphics) is used. |\n|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|"]]
