Classe ImageAccess

  java.lang.Object|+ - -  ImageAccess

classe pública ImageAccess

estende java.lang.Object

ImageAccess é uma camada da relação para facilitar o acesso aos pixels das imagens de ImageJ. Os métodos de ImageAccess fornecem uma maneira fácil e robusta de acesso aos pixels das imagens. Os dados são armazenados em formato double. Muitos métodos get/put são disponíveis para acessar os dados. Se houver uma tentativa do usuário de acessar fora da imagem, as condições de contorno de simetria especular serão aplicadas.

Sumário de Campos
`static` `int`	`PATTERN_CROSS_3x3`
`static` `int`	`PATTERN_SQUARE_3x3`

Sumário de Construtores
`ImageAccess(ij.process.ColorProcessor PC, colorPlane int)` Cria um objeto novo da classe ImageAccess de um objeto de ColorProcessor.
`ImageAccess(double[][] array)` Cria um objeto novo de ImageAccess de uma 2D disposição do double dos pixels.
`ImageAccess(ij.process.ImageProcessor ip)` Cria um objeto novo da classe ImageAccess de um objeto de ImageProcessor.
`ImageAccess(nx int, ny int)` Cría um objeto novo da classe ImageAccess.

Sumário de Métodos
`void`	`abs()` Computa o valor absoluto.
`void`	`add(doubleconstant)` Um objeto de ImageAccess chama este método para adicionar uma constante a cada pixel.
`void`	`add(ImageAccess im1, ImageAccess im2)` Um objeto de ImageAccess chama este método para adicionar dois objetos de ImageAccess.
`ij.process.ByteProcessor`	`createByteProcessor()` Cria um ByteProcessor dos dados do pixel.
`ij.process.FloatProcessor`	`createFloatProcessor()` Cria um FloatProcessor dos dados do pixel.
`void`	`divide(double constant)` Um objeto de ImageAccess chama este método para dividir uma constante a cada pixel.
`void`	`divide( ImageAccess im1, ImageAccess im2)` Um objeto de ImageAccess chama este método para dividir dois objetos de ImageAccess.
`ImageAccess`	`duplicate()` Cria um objeto novo de ImageAccess pela duplicação da corrente o objeto de ImageAccess.
`double[][]`	`getArrayPixels()` Retorna uma cópia dos dados do pixel organizados em um arranjo 2D.
`void`	`getColumn(int x, double[] column)` Um objeto ImageAccess chama este método para acessar uma coluna inteira da imagem.
`void`	`getColumn(int x, int y, double[] column)` Um objeto de ImageAccess chama este método para acessar uma parte da coluna.
`int`	`getHeight()` Retorne a altura da imagem.
`double`	`getInterpolatedPixel(double x, double y)` Um objeto de ImageAccess chama este método para acessar o nível cinzento de um pixel selecionado usando um interpolation bilinear.
`double`	`getMaximum()` Retorne o valor máximo de ImageAccess.
`double`	`getMean()` Retorne o valor médio de ImageAccess.
`double`	`getMinimum()` Retorne o valor mínimo de ImageAccess.
`void`	`getNeighborhood(int x, int y, double[][] neigh)` Um objeto de ImageAccess chama este método para acessar a uma vizinhança em torno de uma posição de pixel.
`void`	`getPattern(int x, int y, double[] neigh, int pattern)`
`double`	`getPixel` `(int x, int y)` Um objeto de ImageAccess chama este método para acessar o nível cinzento de um pixel selecionado.
`double[]`	`getPixels` `()` Retorna uma referência aos dados do pixel no double (1D).
`void`	`getRow(int y, double[] row)` Um objeto de ImageAccess chama este método para acessar uma linha inteira da imagem.
`void`	`getRow(int x, int y, double[] row)` Um objeto de ImageAccess chama este método para acessar uma parte da linha.
`void`	`getSubImage(int x, int y, ImageAccess output)` Um objeto de ImageAccess chama este método para acessar uma sub-imagem com o canto esquerdo superior na coordenada (x,y).
`int`	`getWidth` `()` Retorna a largura da imagem.
`void`	`multiply(double constant)` Um objeto de ImageAccess chama este método para multiplicar uma constante a cada pixel.
`void`	`multiply(ImageAccess im1, ImageAccess im2)` Um objeto de ImageAccess chama este método para multiplicar dois objetos de ImageAccess.
`void`	`normalizeContrast()` ”Estica” o contraste dentro de uma imagem de modo que os níveis cinzentos estejam na escala 0 a 255.
`void`	`pow(double a)` Eleva um objeto de ImageAccess à potência a.
`void`	`putArrayPixels(double[][] array)` Um objeto de ImageAccess chama este método para colocar um arranjo 2D de double em um ImageAccess.
`void`	`putColumn(int x, double[] column)` Um objeto de ImageAccess chama este método para pôr uma coluna inteira em uma posição especificada na imagem.
`void`	`putColumn(int x, int y, double[] column)` Um objeto de ImageAccess chama este método para pôr uma parte da coluna na imagem.
`void`	`putPixel` `(int x, int y, double value)` Um objeto de ImageAccess chama este método em ordem um valor do nível de cinza a ser posto para dentro de uma posição dada pelas coordenadas.
`void`	`putRow(int y, double[] row)` Um objeto de ImageAccess chama este método para pôr uma linha inteira em uma posição especificada na imagem.
`void`	`putRow(int x, int y, double[] row)` Um objeto de ImageAccess chama este método para pôr uma parte da linha na imagem.
`void`	`putSubImage(int x, int y, ImageAccess input)` Um objeto de ImageAccess chama este método para pôr uma sub-imagem com o canto esquerdo superior na coordenada (x,y).
`void`	`setConstant(double constant)` Um objeto de ImageAccess chama este método para ajustar um valor constante a todos os pixels da imagem.
`void`	`show(java.lang.String title)` Mostra uma imagem.
`void`	`show(java.lang.String title, java.awt.Point loc)` Mostra uma imagem em uma posição específica (x, y).
`void`	`sqrt()` Computa a raiz quadrada de um ImageAccess.
`void`	`subtract(double constant)` Um objeto de ImageAccess chama este método para subtrair uma constante a cada pixel.
`void`	`subtract(ImageAccess im1, ImageAccess im2)` Um objeto de ImageAccess chama este método para subtrair duas imagens ImageAccess.

Métodos herdados da classe java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Detalhes de Campos

PATTERN_SQUARE_3x3

  public static final int PATTERN_SQUARE_3x3

PATTERN_CROSS_3x3

  public static final int PATTERN_CROSS_3x3

Detalhe Do Construtor

ImageAccess

  public ImageAccess(double[][] array)

Cría um objeto novo de ImageAccess de uma matriz 2D de double dos pixels. O tamanho da matriz determina o tamanho da imagem.

Parâmetros:

array - uma matriz de pixels (2D)

ImageAccess

  public ImageAccess(ij.process.ImageProcessor ip)

Cría um objeto novo da classe ImageAccess de um objeto ImageProcessor. O objeto ImageProcessor contem os dados da imagem, o tamanho e o tipo da imagem. O ImageProcessor está fornecido por ImageJ, ele se por um 8-bit, 16-bit.

Parâmetros:

IP - um objeto de ImageProcessor fornecido por ImageJ

ImageAccess

  public ImageAccess(ij.process.ColorProcessor cp,

                   int colorPlane)

Cría um objeto novo da classe ImageAccess de um objeto de ColorProcessor. O objeto de ImageProcessor contem os dados da imagem, o tamanho e o tipo da imagem. O ColorProcessor é fornecido por ImageJ, o ImageAccess contem um plano (vermelho, verde ou azul) selecionado com o parâmetro do colorPlane.

Parâmetros:

PC - um objeto de ColorProcessor

colorPlane - índice do plano de cor 0, 1 ou 2

ImageAccess

  public ImageAccess(int nx,

                   int ny)

Cría um objeto novo da classe ImageAccess. O tamanho da imagem é dado como o parâmetro. Os pixels dos dados estão vazios e não são inicializados.

Parâmetros:

nx - o tamanho da imagem ao longo do eixo x

ny - o tamanho da imagem ao longo do eixo y

Detalhe de Métodos

getWidth

  public int getWidth()

Retorne a largura da imagem.

Retornos:

a largura da imagem

getHeight

  public int getHeight()

Retorna a altura da imagem.

Retornos:

a altura da imagem

getMaximum

  public double getMaximum()

Retorna o valor máximo de ImageAccess.

Retornos:

o valor máximo

getMinimum

  public double getMinimum()

Retorna o valor mínimo de ImageAccess.

Retornos:

o valor mínimo

getMean

  public double getMean()

Retorna o valor médio de ImageAccess.

Retornos:

o valor médio

getArrayPixels

  public double[][] getArrayPixels()

Retorna uma cópia dos dados do pixel organizados em uma matriz 2D.

Retornos:

a 2D disposição do double

getPixels

  public double[] getPixels()

Retorna uma referência aos dados dos pixels em double (1D).

Retornos:

Vetor de double dos pixels em 1D

createFloatProcessor

  public ij.process.FloatProcessor createFloatProcessor()

Cria um FloatProcessor dos dados do pixel.

Retornos:

o FloatProcessor

createByteProcessor

  public ij.process.ByteProcessor createByteProcessor()

Cria um ByteProcessor dos dados do pixel.

Retornos:

o ByteProcessor

duplicate

  public ImageAccess duplicate()

Cria um objeto novo de ImageAccess pela duplicação do objeto corrente de ImageAccess.

Retornos:

um objeto novo de ImageAccess

getPixel

  public double getPixel(int x,

                       int y)

Um objeto de ImageAccess chama este método para acessar o nível cinzento de um pixel selecionado. As condições da beira do espelho são aplicadas.

Parâmetros:

a entrada x, o inteiro coordenada x de um pixel

a entrada y, o inteiro coordenada y de um pixel

Retornos:

o nível de cinza do pixel (double)

getInterpolatedPixel

  public double getInterpolatedPixel(double x,

                                   double y)

Um objeto de ImageAccess chama este método para acessar o nível de cinza de um pixel selecionado usando interpolação bilinear. As coordenadas devem ser dadas em double e a interpolação bilinear é aplicada para achar o nível de cinza. As condições da contorno do espelho são aplicadas.

Parâmetros:

a entrada x, a coordenada double x de um pixel

a entrada y, a coordena double y de um pixel

Retornos:

o nível de cinzao do pixel (double)

getColumn

  public void getColumn(int x,

                      double[] column)

Um objeto de ImageAccess chama este método para acessar uma coluna inteira da imagem. A coluna deve criada já com o tamanho correto [ny].

Parâmetros:

x - a entrada, o inteiro x-coordena de uma coluna

column - saída, uma disposição do double do tipo

getColumn

  public void getColumn(int x,

                      int y,

                      double[] column)

Um objeto de ImageAccess chama este método para acessar uma parte da coluna. O ponto início é dado pelo parâmetro de y e o final determinado pelo tamanho do parâmetro colunm. O parâmetro column já deve estar criado.

Parâmetros:

x - entrada, o inteiro coordenada x de uma coluna

y - entrada, ponto início

column - saída, um vetor do tipo double

getRow

  public void getRow(int y,

                   double[] row)

Um objeto de ImageAccess chama este método para acessar uma linha inteira da imagem. A linha deve criado já com o tamanho correto [ nx ].

Parâmetros:

y - a entrada, o inteiro coordenada y de uma linha

row - saída, um vetor do tipo double

getRow

  public void getRow(int x,

                   int y,

                   double[] row)

Um objeto de ImageAccess chama este método para acessar uma parte da linha. O ponto início é dado pelo parâmetro de y e o fim determinado pelo tamanho do parâmetro row. O parâmetro row deve estar criado já.

Parâmetros:

x - entrada, ponto início

y - a entrada, o inteiro coordenada y de uma linha

row - saída, um vetor do tipo double

getNeighborhood

public void getNeighborhood(int x,

                            int y,

                            double[][] neigh)

Um objeto ImageAccess chama este método para acessar uma vizinhança em torno da posição de um pixel. O parâmetro neigh já deve estar criado. O tamanho da matriz determina o tamanho da vizinhança. Condições de fronteiras reflexivas são aplicadas.

O valor de pixel de (x-n/2, y-n/2) é colocado em neigh[0][0]
...
O valor de pixel de (x+n/2, y+n/2) é colocado em neigh[n-1][n-1]

Por exemplo, se neigh é um double[4][4]:
O valor de pixel de (x-1, y-1) é colocado em neigh[0][0]
O valor de pixel de (x , y ) é colocado em neigh[1][1]
O valor de pixel de (x+1, y+1) é colocado em neigh[2][2]
O valor de pixel de (x+2, y+2) é colocado em neigh[3][3]
...
Por exemplo, se neigh é um double[5][5]:
O valor de pixel de (x-2, y-2) é colocado em neigh[0][0]
O valor de pixel de (x-1, y-1) é colocado em neigh[1][1]
O valor de pixel de (x , y ) é colocado em neigh[2][2]
O valor de pixel de (x+1, y+1) é colocado em neigh[3][3]
O valor de pixel de (x+2, y+2) é colocado em neigh[4][4]

Parameters:

x - o inteiro coordenada x de um pixel central selecionado

y - o inteiro coordenada y de um pixel central selecionado

neigh - output, a 2D array s

getPattern

public void getPattern(int x,

                       int y,

                       double[] neigh,

                       int pattern)

Um objeto ImageAccess chama este método para acessar uma vizinhança de padrão definido em torno de um pixel selecionado (x,y).
Os padrões disponíveis são:
- um bloco 3*3: PATTERN_SQUARE_3x3 (8-connect)
- uma cruz 3*3: PATTERN_CROSS_3x3 (4-connect)

Condições de fronteiras reflexivas são aplicadas.
Os pixels são arranjados em um vetor 1D, de acordo com as seguintes regras:

Se o padrão é PATTERN_SQUARE_3x3 (8-connect)
O valor de pixel de (x-1, y-1) é colocado em neigh[0]
O valor de pixel de (x , y-1) é colocado em neigh[1]
O valor de pixel de (x+1, y-1) é colocado em neigh[2]
O valor de pixel de (x-1, y ) é colocado em neigh[3]
O valor de pixel de (x , y ) é colocado em neigh[4]
O valor de pixel de (x+1, y ) é colocado em neigh[5]
O valor de pixel de (x-1, y+1) é colocado em neigh[6]
O valor de pixel de (x , y+1) é colocado em neigh[7]
O valor de pixel de (x+1, y+1) é colocado em neigh[8]

Se o padrão é PATTERN_CROSS_3x3 (4-connect)
O valor de pixel de (x , y-1) é colocado em neigh[0]
O valor de pixel de (x-1, y ) é colocado em neigh[1]
O valor de pixel de (x , y ) é colocado em neigh[2]
O valor de pixel de (x+1, y ) é colocado em neigh[3]
O valor de pixel de (x , y+1) é colocado em neigh[4]

O vetor neigh deve já estar criado como um vetor double de 9 elementos para PATTERN_SQUARE_3x3 ou 5 elementos para PATTERN_CROSS_3x3.

Parâmetros:

x – coordenada x de um pixel central selecionado

y - coordenada y de um pixel central selecionado

neigh – saida, um vetor de 9 ou 5 elementos

pattern - PATTERN_SQUARE_3x3 ou PATTERN_CROSS_3x3.

getSubImage

public void getSubImage(int x,

                        int y,

                        ImageAccess output)

An ImageAccess object calls this method to get a sub-image with the upper left corner in the coordinate (x,y). The sub-image ouptut should be already created.

Parameters:

x - x-coordinate in the source image

y - y-coordinate in the source image

output - an ImageAccess object with the sub-image;

putPixel

public void putPixel(int x,

                     int y,

                     double value)

An ImageAccess object calls this method in order a value of the gray level to be put to a position inside it given by the coordinates.

Parameters:

x - input, the integer x-coordinate of a pixel

y - input, the integer y-coordinate of a pixel

value - input, a value of the gray level of the type double

putColumn

public void putColumn(int x,

                      double[] column)

An ImageAccess object calls this method to put a whole column in a specified position into the image.

Parameters:

x - input, the integer x-coordinate of a column

column - input, an array of the type double

putColumn

public void putColumn(int x,

                      int y,

                      double[] column)

An ImageAccess object calls this method to put a part of column into the image. The starting poisition in given by y and the ending position is determined by the size of the column array.

Parameters:

x - input, the integer x-coordinate of a column

y - input, the integer y-coordinate of a column

column - input, an array of the type double

putRow

public void putRow(int y,

                   double[] row)

An ImageAccess object calls this method to put a whole row in a specified position into the image.

Parameters:

y - input, the integer x-coordinate of a column

row - input, an array of the type double

putRow

public void putRow(int x,

                   int y,

                   double[] row)

An ImageAccess object calls this method to put a part of row into the image. The starting poisition in given by x and the ending position is determined by the size of the row array.

Parameters:

x - input, the integer x-coordinate of a column

y - input, the integer y-coordinate of a column

row - input, an array of the type double

putArrayPixels

public void putArrayPixels(double[][] array)

An ImageAccess object calls this method in order to put an 2D array of double in an ImageAccess.

Parameters:

array - input, the double array

putSubImage

public void putSubImage(int x,

                        int y,

                        ImageAccess input)

An ImageAccess object calls this method to put a sub-image with the upper left corner in the coordinate (x,y). The sub-image input should be already created.

Parameters:

x - x-coordinate in the source image

y - y-coordinate in the source image

input - an ImageAccess object that we want to put;

setConstant

public void setConstant(double constant)

An ImageAccess object calls this method to set a constant value to all pixels of the image.

Parameters:

constant - a constant value

normalizeContrast

public void normalizeContrast()

Stretches the contrast inside an image so that the gray levels are in the range 0 to 255.

show

public void show(java.lang.String title,

                 java.awt.Point loc)

Display an image at a specific position (x, y).

Parameters:

title - a string for the title

loc - Point for the location

show

public void show(java.lang.String title)

Display an image.

Parameters:

title - a string for the title of the window

abs

public void abs()

Compute the absolute value.

sqrt

public void sqrt()

Compute the square root of an ImageAccess.

pow

public void pow(double a)

Raised an ImageAccess object to the power a.

Parameters:

a - input

add

public void add(double constant)

An ImageAccess object calls this method for adding a constant to each pixel.

Parameters:

constant - a constant to be added

multiply

public void multiply(double constant)

An ImageAccess object calls this method for multiplying a constant to each pixel.

Parameters:

constant - a constant to be multiplied

subtract

public void subtract(double constant)

An ImageAccess object calls this method for adding a constant to each pixel.

Parameters:

constant - a constant to be added

divide

public void divide(double constant)

An ImageAccess object calls this method for dividing a constant to each pixel.

Parameters:

constant - a constant to be multiplied

add

public void add(ImageAccess im1,

                ImageAccess im2)

An ImageAccess object calls this method for adding two ImageAccess objects. [this = im1 + im2] The resulting ImageAccess and the two operands should have the same size.

Parameters:

im1 - an ImageAccess object to be added

im2 - an ImageAccess object to be added

multiply

public void multiply(ImageAccess im1,

                     ImageAccess im2)

An ImageAccess object calls this method for multiplying two ImageAccess objects. The resulting ImageAccess and the two operands should have the same size. [this = im1 * im2]

Parameters:

im1 - an ImageAccess object to be multiplied

im2 - an ImageAccess object to be multiplied

subtract

public void subtract(ImageAccess im1,

                     ImageAccess im2)

An ImageAccess object calls this method for subtracting two ImageAccess objects. The resulting ImageAccess and the two operands should have the same size. [this = im1 - im2]

Parameters:

im1 - an ImageAccess object to be subtracted

im2 - an ImageAccess object to be subtracted

divide

public void divide(ImageAccess im1,

                   ImageAccess im2)

An ImageAccess object calls this method for dividing two ImageAccess objects. [this = im1 / im2] The resulting ImageAccess and the two operands should have the same size.

Parameters:

im1 - numerator

im2 - denominator