MonkeyImage
Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
Una clase de monkeyrunner para conservar una imagen de la pantalla del dispositivo o el emulador. La imagen se copia del búfer de la pantalla durante una captura de pantalla. Los métodos de este objeto permiten convertir la imagen en varios formatos de almacenamiento, escribir la imagen en un archivo, copiar partes de esta y comparar el objeto con otros de MonkeyImage
.
No es necesario crear instancias nuevas de MonkeyImage
. En su lugar, usa
MonkeyDevice.takeSnapshot()
para crear una instancia nueva a partir de una captura de pantalla. Por ejemplo, usa:
newimage = MonkeyDevice.takeSnapshot()
Resumen
Métodos |
string
|
convertToBytes
(formato de string)
Convierte la imagen actual a un formato determinado y la muestra como una string, a la que luego puedes acceder como iterable de bytes binarios.
|
tuple
|
getRawPixel
(integer x,
integer y)
Muestra el píxel único de la ubicación de la imagen (x,y), como un tuple de integer, con el formato (a,r,g,b).
|
integer
|
getRawPixelInt
(integer x,
integer y)
Muestra el único píxel en la ubicación de imagen (x,y), como un número entero de 32 bits.
|
MonkeyImage
|
getSubImage
(tuple rect)
Crea un nuevo objeto MonkeyImage a partir de una selección rectangular de la imagen actual.
|
boolean
|
sameAs
(otro MonkeyImage
,
porcentaje de float)
Compara este objeto MonkeyImage con otro y muestra el resultado de la comparación. El argumento percent especifica la diferencia de porcentaje que se permite para que las dos imágenes sean "iguales".
|
void
|
writeToFile
(ruta de acceso de string,
formato de string)
Escribe la imagen actual en el archivo especificado por filename , en el formato especificado por format .
|
Métodos públicos
Convierte la imagen actual a un formato determinado y lo muestra como una string, a la que luego puedes acceder como un objeto iterable de bytes binarios.
Argumentos
format |
Es el formato de salida deseado. Todos los formatos de salida de trama comunes son compatibles.
El valor predeterminado es "png" (Gráficos de red portátiles).
|
tuple
getRawPixel
(integer x,
integer y)
Muestra el único píxel en la ubicación de la imagen (x,y), como una tupla de número entero, con el formato (a,r,g,b).
Argumentos
x |
Posición horizontal del píxel, comenzando por 0 en la parte izquierda de la pantalla, en la orientación que tenía cuando se tomó la captura de pantalla.
|
y |
Posición vertical del píxel, comenzando por 0 en la parte superior de la pantalla, en la orientación que tenía cuando se tomó la captura de pantalla.
|
Resultado que se muestra
-
Es una tupla de números enteros que representa el píxel, en el formato (a,r,g,b), donde a es el valor del canal alfa, y r, g y b son los valores rojo, verde y azul respectivamente.
tuple
getRawPixelInt
(integer x,
integer y)
Muestra el único píxel en la ubicación de imagen (x,y), como un número entero. Usa este método para ahorrar memoria.
Argumentos
x |
Posición horizontal del píxel, comenzando por 0 en la parte izquierda de la pantalla, en la orientación que tenía cuando se tomó la captura de pantalla.
|
y |
Posición vertical del píxel, comenzando por 0 en la parte superior de la pantalla, en la orientación que tenía cuando se tomó la captura de pantalla.
|
Resultado que se muestra
-
Valores a, r, g y b del píxel como valores de 8 bits combinados en un número entero de 32 bits, donde a representa los primeros 8 bits de la izquierda, r los siguientes hacia la derecha, y así sucesivamente.
MonkeyImage
getSubImage
(tuple rect)
Crea un nuevo objeto MonkeyImage
a partir de una selección rectangular de la imagen actual.
Argumentos
rect |
Es una tupla (x, y, w, h) que especifica la selección. x e y especifican la posición del píxel basada en 0 de la esquina superior izquierda de la selección; w especifica el ancho de la región y h especifica la altura, ambos medidos en píxeles.
La orientación de la imagen es la misma que la que tenía la pantalla al momento de realizar la captura de pantalla.
|
Resultado que se muestra
-
Un nuevo objeto
MonkeyImage
que contiene la selección.
boolean
sameAs
(
MonkeyImage
otherImage,
porcentaje de float
)
Compara este objeto MonkeyImage
con otro y muestra el resultado de la comparación. El argumento percent
especifica la diferencia de porcentaje permitida para que las dos imágenes sean "iguales".
Argumentos
other |
Es otro objeto MonkeyImage para comparar con este.
|
percent |
Es un número de punto flotante en el rango de 0.0 a 1.0 inclusive, que indica el porcentaje de píxeles que deben ser iguales para que el método muestre true . El valor predeterminado es 1.0 e indica que todos los píxeles deben coincidir.
|
Resultado que se muestra
-
Es un valor booleano
true
si las imágenes coinciden, o bien un valor booleano false
si no lo hacen.
Escribe la imagen actual en el archivo especificado por filename
, en el formato especificado por format
.
Argumentos
path |
Es el nombre de archivo completo y extensión del archivo de salida. |
format |
Formato de salida que se usará para el archivo. Si no se proporciona ningún formato, el método intentará adivinarlo a partir de la extensión del nombre de archivo. Si no se proporciona ninguna extensión y no se especifica ningún formato, se utilizará el formato predeterminado PNG (Gráficos de red portátiles).
|
El contenido y las muestras de código que aparecen en esta página están sujetas a las licencias que se describen en la Licencia de Contenido. Java y OpenJDK son marcas registradas de Oracle o sus afiliados.
Última actualización: 2025-07-27 (UTC)
[null,null,["Última actualización: 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|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|"]]