# Programação

No &krita;, você poderá criar programas em Ruby ou Python (a disponibilidade dos interpretadores poderá depender da sua distribuição ou se o administrador da sua máquina os instalou). Aqui você poderá encontrar uma descrição da API de programação.

Alguns dos exemplos são distribuídos com o &krita; e você poderá encontrá-los em `/usr/share/apps/krita/scripts` (ou `/opt/kde/share/apps/krita/scripts`).

## Variáveis do módulo `Krosskritacore`

- O `KritaDocument` retorna um objeto `Document`

- O `KritaScript` retorna um objeto `ScriptProgress`

Você poderá obter um objeto com a função `get` do módulo `Krosskritacore`; no Ruby, você terá que escrever algo como:

    doc = Krosskritacore::get("KritaDocument")
    programa = Krosskritacore::get("KritaScript")

## Funções no módulo `Krosskritacore`

- Função: `getBrush`

  Esta função retorna um `Brush` obtido da lista de recursos do &krita;. Recebe um argumento: o nome do pincel. Por exemplo (em Ruby):

      Krosskritacore::getBrush("Circle (05)")

- Função: `getFilter`

  Esta função retorna um `Filter` obtido da lista de recursos do &krita;. Recebe um argumento: o nome do filtro. Por exemplo (em Ruby):

      Krosskritacore::getFilter("invert")

- Função: `getPattern`

  Esta função retorna um `Pattern` obtido da lista de recursos do &krita;. Recebe um argumento: o nome do padrão. Por exemplo (em Ruby):

      Krosskritacore::getPattern("Bricks")

- Função: `loadBrush`

  Esta função carrega um `Brush` e retorna-o em seguida. Ela recebe um argumento: o nome do arquivo do pincel.

- Função: `loadPattern`

  Esta função carrega um `Pattern` e retorna-o em seguida. Ela recebe um argumento: o nome do arquivo do padrão.

- Função: `newCircleBrush`

  Esta função retorna um `Brush` com uma forma circular. Recebe pelo menos dois argumentos: a largura e a altura. Poderá receber outros dois argumentos: a largura e a altura do sombreado. Se não for indicado qualquer sombreado, ele não será usado. Por exemplo (em Ruby):

      Krosskritacore::newCircleBrush(10,20) # cria um círculo simples
      Krosskritacore::newCircleBrush(10,20,5,10) # cria um gradiente

- Função: `newHSVColor`

  Esta função retorna uma nova `Color` com a tripla HSV fornecido. Recebe três argumentos: a componente do matiz (0 a 255), da saturação (0 a 255) e do valor (0 to 255). Por exemplo (em Ruby):

      Krosskritacore::newHSVColor(255,125,0)

- Função: `newImage`

  Esta função retorna uma nova `Image`. Recebe quatro argumentos: largura, altura, ID do espaço de cores, nome da imagem. Como resultado, irá obter um objeto `Image`. Por exemplo (em Ruby):

      Krosskritacore::newImage(10,20, "RGBA", "kikoo")

- Função: `newRectBrush`

  Esta função retorna um `Brush` com uma forma retangular. Recebe pelo menos dois argumentos: a largura e a altura. Poderá receber outros dois argumentos: a largura e a altura do sombreado. Se não for indicado qualquer sombreado, ele não será usado. Por exemplo (em Ruby):

      Krosskritacore::newRectBrush(10,20) # criar um retângulo simples
       Krosskritacore::newRectBrush(10,20,5,10) # criar um gradiente

- Função: `newRGBColor`

  Esta função retorna uma nova `Color` com a tripla RGB fornecida. Recebe três argumentos: a componente do vermelho (0 a 255), do verde (0 a 255) e do azul (0 to 255). Por exemplo (em Ruby):

      Krosskritacore::newRGBColor(255,0,0) # criar uma cor vermelha
      Krosskritacore::newRGBColor(255,255,255) # criar uma cor branca

## Descrições e listas de funções dos vários objetos no `Krosskritacore`

- Objeto: PaintLayer

  - Função: `beginPainting`

  - Função: `convertToColorspace`

    Converte a imagem para um espaço de cores. Esta função recebe um argumento: o nome do espaço de cores de destino. Por exemplo (em Ruby):

        image.convertToColorspace("CMYK")

  - Função: `createHistogram`

    Esta função cria um histograma para esta camada. Recebe dois argumentos: o tipo do histograma ("RGB8HISTO") e 0 se o histograma for linear ou 1 se for logarítmico.

  - Função: `createHLineIterator`

    Cria um iterador sobre uma camada, que irá percorrer uma linha. Esta função recebe três argumentos: `x` (início na linha), `y` (posição vertical da linha), largura da linha.

  - Função: `createPainter`

    Esta função cria um `Painter` que lhe permitirá pintar na camada.

  - Função: `createRectIterator`

    Cria um iterador sobre uma camada, que irá funcionar sobre uma área retangular. Esta função recebe quatro argumentos: `x`, `y`, largura do retângulo, altura do retângulo.

  - Função: `createVLineIterator`

    Cria um iterador sobre uma camada, que irá percorrer uma coluna. Esta função recebe três argumentos: `x` (posição horizontal da coluna), `y` (início da coluna), altura da coluna.

  - Função: `endPainting`

    Esta função fecha o item a desfazer atual e adiciona-o ao histórico.

  - Função: `fastWaveletTransformation`

    Retorna a transformação por ondulação da camada.

  - Função: `fastWaveletUntransformation`

    Anula uma ondulação desta camada. Recebe um argumento: um objeto de ondulação. Por exemplo (em Ruby):

        wavelet = camada.fastWaveletTransformation()
        camada.fastWaveletUntransformation(wavelet)

  - Função: `getHeight`

    Retorna a altura da camada.

  - Função: `getWidth`

    Retorna a largura da camada.

- Objeto: `Filter`

  - Função: `getFilterConfiguration`

    Esta função retorna a `FilterConfiguration` associada com este filtro.

  - Função: `process`

    Esta função irá aplicar o filtro. Recebe pelo menos um argumento: a camada de origem. Você poderá também usar estes quatro argumentos: `x`, `y`, `largura`, `altura`. O (`x`,`y`,`largura`,`altura`) define a área retangular na qual será calculado o filtro. Se o retângulo não for definido, então o filtro será aplicado na camada de origem inteira. Por exemplo (em Ruby)

        doc = Krosskritacore::get("KritaDocument")
        imagem = doc.getImage()
        camada = imagem.getActivePaintLayer()
        largura = camada.getWidth()
        altura = camada.getHeight()
        filtro = Krosskritacore::getFilter("invert")
        filtro.process(camada, camada)
        filtro.process(camada, camada, 10, 10, 20, 20 )

- Objeto: `FilterConfiguration`

  - Função: `getProperty`

    Esta função retorna o valor de um parâmetro do `Filter` associado. Ele recebe um argumento: o nome do parâmetro.

  - Função: `setProperty`

    Esta função define um parâmetro do `Filter` associado. Ela recebe dois argumentos: o nome do parâmetro e o valor, cujo tipo depende do `Filter`.

- Objeto: `Histogram`

  Esta classe permite-lhe acessar o histograma de um `PaintLayer`. Exemplo (em Ruby):

      doc = krosskritacore::get("KritaDocument")
       imagm = doc.getImage()
       camada = imagem.getActiveLayer()
       histo = camada.createHistogram("RGB8HISTO",0)
       min = camada.getMin() * 255
       max = camada.getMax() * 255
       for i in min..max
         print camada.getValue(i)
         print "\n"
       end

  - Função: `getChannel`

    Retorna o canal selecionado.

  - Função: `getCount`

    Esta função retorna o número de pixels usados pelo histograma.

  - Função: `getHighest`

    Esta função retorna o valor mais elevado do histograma.

  - Função: `getLowest`

    Esta função retorna o valor mínimo do histograma.

  - Função: `getMax`

    Esta função retorna o limite máximo do histograma (os valores com maior posição onde os máximos são nulos). O valor está no intervalo 0.0 – 1.0.

  - Função: `getMean`

    Esta função retorna a média do histograma.

  - Função: `getMin`

    Esta função retorna o limite mínimo do histograma (os valores com menor posição onde os máximos são nulos). O valor está no intervalo 0.0 – 1.0.

  - Função: `getNumberOfBins`

    Retorna o número de abcissas deste histograma.

  - Função: `getTotal`

    Esta função retorna o somatório de todos os valores do histograma.

  - Função: `getValue`

    Retorna o valor de uma abcissa do histograma. Esta função recebe um argumento: índice, no intervalo [0..255].

  - Função: `setChannel`

    Seleciona o canal da camada para o qual irá obter o resultado do histograma. Esta função recebe um argumento: o número do canal.

- Objeto: `ScriptProgress`

  O `ScriptProgress` é usado para gerenciar a barra de progresso da barra de estado do &krita;. Por exemplo (em Ruby):

      programa = Krosskritacore::get("KritaScript")
      programa.setProgressTotalSteps(1000)
      programa.setProgressStage("progressive", 0)
      for i in 1..900
        programa.incProgress()
      end
      programa.setProgressStage("brutal", 1000)

  - Função: `incProgress`

    Esta função avança um passo no progresso.

  - Função: `setProgress`

    Esta função altera o valor do progresso. Recebe um argumento: o valor do progresso.

  - Função: `setProgressStage`

    Esta função altera o valor do progresso e mostra o texto.

  - Função: `setProgressTotalSteps`

    Esta função define o número de passos que o programa irá necessitar. Recebe um argumento: o valor máximo do progresso

- Objeto: `Wavelet`

  Este objeto contém os coeficientes de uma transformação por ondulação de um `PaintLayer`.

  - Função: `getDepth`

    Retorna a profundidade da camada.

  - Função: `getNCoeff`

    Retorna o valor do N-ésimo coeficiente. A função recebe um argumento: o índice do coeficiente.

  - Função: `getNumCoeffs`

    Retorna o número de coeficientes nesta ondulação (= tamanho * tamanho * profundidade).

  - Função: `getSize`

    Retorna o tamanho da ondulação (tamanho = largura = altura).

  - Função: `getXYCoeff`

    Retorna o valor de um coeficiente. A função recebe dois argumentos: `x` e `y`.

  - Função: `setNCoeff`

    Altera o valor do N-ésimo coeficiente. A função recebe dois argumentos: o índice do coeficiente e o novo valor do coeficiente.

  - Função: `setXYCoeff`

    Altera o valor de um coeficiente. A função recebe três argumentos: `x`, `y` e o novo valor do coeficiente.

- Objeto: `Painter`

  - Função: `convolve`

    Esta função aplica um módulo de convolução a uma imagem. Recebe pelo menos três argumentos: uma lista de módulos (todas as listas deverão ter o mesmo tamanho), o fator e o deslocamento.

    O valor de um pixel será fornecido pela seguinte função: K * P / factor + deslocamento, onde o K é o módulo e o P a vizinhança.

    Poderá receber os seguintes argumentos opcionais: `opContorno` (controla como fazer a convolução dos pixels no extremo de uma imagem: 0 = usar a cor padrão, 1 = usa o pixel do lado oposto da imagem, 2 = usar o pixel do contorno, 3 = evitar os pixels do contorno), `canal` (1 para a cor, 2 para o alfa, 3 para ambos), `x`, `y`, `largura`, `altura`.

  - Função: `setFillThreshold`

    Define o limiar de preenchimento. Recebe um argumento: o limite.

  - Função: `fillColor`

    Começa a preencher com uma cor. Recebe dois argumentos: `x` e `y`.

  - Função: `fillPattern`

    Começa a preencher com um padrão. Recebe dois argumentos: `x` e `y`.

  - Função: `paintPolyline`

    Esta função irá pintar uma linha poligonal. Recebe dois argumentos: uma lista de posições em X e uma lista de posições em Y.

  - Função: `paintLine`

    Esta função irá pintar uma linha. Ele recebe cinco argumentos: `x1`, `y1`, `x2`, `y2` e `pressão`.

  - Função: `paintBezierCurve`

    Esta função irá pintar uma curva Bezier. Recebe dez argumentos: `x1`, `y1`, `p1`, `cx1`, `cy1`, `cx2`, `cx2`, `x2`, `y2`, `p2`, onde o (`x1`,`y1`) é a posição inicial, o `p1` é a pressão inicial, (`x2`,`y2`) é a posição final, `p2` é a pressão no fim. O (`cx1`,`cy1`) e o (`cx2`,`cy2`) são as posições dos pontos de controle.

  - Função: `paintEllipse`

    Esta função irá pintar uma elipse. Recebe cinco argumentos: `x1`, `y1`, `x2`, `y2`, `pressão`, onde o (`x1`,`y1`) e o (`x2`,`y2`) são as posições dos dois centros.

  - Função: `paintPolygon`

    Esta função irá pintar um polígono. Recebe dois argumentos: uma lista de posições em X e uma lista de posições em Y.

  - Função: `paintRect`

    Esta função irá pintar um retângulo. Recebe cinco argumentos: `x`, `y`, `largura` `altura`, `pressão`.

  - Função: `paintAt`

    Esta função irá pintar numa posição fornecida. Recebe três argumentos: `x`, `y`, `pressão`.

  - Função: `setPaintColor`

    Esta função define a cor de pintura (também chamada de cor principal). Recebe um argumento: um `Color`.

  - Função: `setBackgroundColor`

    Esta função altera a cor de fundo. Recebe um argumento: uma `Color`.

  - Função: `setPattern`

    Esta função altera o padrão usado no preenchimento. Recebe um argumento: um objeto `Pattern`.

  - Função: `setBrush`

    Esta função altera o pincel usado na pintura. Recebe um argumento: um objeto `Brush`.

  - Função: `setPaintOp`

    Esta função define a operação de pintura. Recebe um argumento: o nome da operação de pintura.

  - Função: `setDuplicateOffset`

    Esta função define o deslocamento da duplicata. Recebe dois argumentos: o deslocamento horizontal e o vertical.

  - Função: `setOpacity`

    Esta função altera a opacidade da pintura. Recebe um argumento: a opacidade, no intervalo de 0 a 255.

  - Função: `setStrokeStyle`

    Esta função define o estilo do traço. Recebe um argumento: 0 para nenhum e 1 para pincel.

  - Função: `setFillStyle`

    Esta função altera o estilo de preenchimento do `Painter`. Recebe um argumento: 0 para nada, 1 para o preenchimento com a cor principal, 2 para o preenchimento com a cor de fundo e 3 para o preenchimento com um padrão.

- Objeto: `Iterator`

  Este objeto permite-lhe alterar os valores dos pixels um a um. O nome de algumas funções depende do espaço de cores; por exemplo, se o espaço de cores da camada for o RGB, terá o `setR`, `setG` e o `setB` e, no caso do CMYK: `setC`, `setM`, `setY` e `setK`. Na documentação abaixo, nós consideraremos que o espaço de cores se chamada ABC, com três canais: A, B e C.

  - Funções: `setA`, `setB`, `setC`

    Estas funções recebem um argumento: o novo valor de um dos canais deste pixel.

  - Função: `setABC`

    Altera o valor de todos os canais. Esta função recebe um argumento: uma lista com os valores novos de todos os canais.

  - Funções: `getA`, `getB`, `getC`

    Retorna o valor de um dos canais deste pixel.

  - Função: `getABC`

    Retorna uma lista com os valores de todos os canais.

  - Função: `darken`

    Torna um pixel mais escuro. Esta função recebe pelo menos um argumento: `sombra` (quantidade usada para escurecer todos os canais de cores). Esta função poderá receber o seguinte argumento opcional: `compensação` (para limitar o escurecimento).

  - Função: `invertColor`

    Inverte a cor de um pixel.

  - Função: `next`

    Incrementa a posição, indo para o pixel seguinte.

  - Função: `isDone`

    Devolve 'true' (verdadeiro) se o iterador estiver no fim (não existirem mais pixels).

## Recursos

Aqui estão sugestões ou listas parciais de recursos do &krita;.

Para o `Brush` e o `Pattern`: Você poderá obter o nome e o pincel ou padrão associado do seletor da barra de ferramentas do &krita;.

Uma lista de identificadores de espaços de cores no &krita;: LABA, RGBA, RGBA16, RGBAF32, RGBAF16HALF, LMSAF32, GRAYA, GRAYA16, CMYK, CMYKA16.