Convertendo imagem BMP para um conjunto de instruções para uma plotadora?

Eu tenho uma plotadora como esta: Dispositivo PloterXY.

A tarefa que tenho que implementar é a conversão de 24 bits BMP para o conjunto de instruções para esta plotadora. Na plotadora, posso alterar 16 colors comuns. A primeira complexidade que enfrento é a redução de colors. A segunda complexidade que enfrento é como transformar os pixels em um conjunto de instruções de desenho.

Como escova de ferramentas de desenho com tinta a óleo será usado. Isso significa que as linhas de desenho da plotadora não serão tão pequenas e serão relativamente curtas.

Por favor sugira algoritmos que possam ser usados ​​para resolver este problema de conversão de dados de imagem?

Alguns resultados iniciais:

Flor 1 - redução de cores.

Flor 2 - redução de cores.

Flor 3 - redução de cores.

Pontilhado

Bem, eu tenho algum tempo para isso hoje, então aqui o resultado. Você não forneceu a paleta de colors da plotadora para extraí-la das imagens resultantes, mas é possível usar qualquer uma delas. A idéia por trás do dithering é simples: a nossa percepção integra a cor na área e não nos pixels individuais, então você tem que usar algum acumulador de diferença de cor do que é renderizado e o que deve ser renderizado e adicioná-lo ao próximo pixel …

Desta forma, a área tem aproximadamente a mesma cor, mas apenas um número discreto de colors é usado em reais. A forma de como atualizar essas informações pode diferenciar o pontilhamento de ramificação de resultados para vários methods. O simples simples é este:

  1. redefinir o acumulador de colors para zero
  2. processar todos os pixels
    1. para cada pixel adicione sua cor ao acumulador
    2. encontre a correspondência mais próxima do resultado na sua paleta
    3. renderizar paleta selecionada
    4. subtraente cor da paleta selecionada do acumulador

Aqui a sua imagem de input (eu colocá-los juntos):

entrada

Aqui resulta imagem para sua fonte:

resultado

Os quadrados coloridos no canto superior esquerdo são apenas a paleta que usei (extraída da sua imagem).

Aqui código ( C ++ ) eu faço isso com:

picture pic0,pic1,pic2; // pic0 - source img // pic1 - source pal // pic2 - output img int x,y,i,j,d,d0,e; int r,g,b,r0,g0,b0; color c; List pal; // resize output to source image size clear with black pic2=pic0; pic2.clear(0); // create distinct colors pal[] list from palette image for (y=0;y=0) pal.add(c); } // dithering r0=0; g0=0; b0=0; // no leftovers for (y=0;yd)) { d0=d; j=i; } } // get selected palette color c=pal[j]; // sub from leftovers r0-=WORD(c.db[picture::_r]); g0-=WORD(c.db[picture::_g]); b0-=WORD(c.db[picture::_b]); // copy to destination image pic2.p[y][x]=c; } // render found palette pal[] (visual check/debug) x=0; y=0; r=16; g=pic2.xs/r; if (g>pal.num) g=pal.num; for (y=0;y 

onde a picture é minha class de imagem então aqui alguns membros:

  • resolução de xs,ys
  • color p[ys][xs] access direto a pixels (formato de pixel de 32 bits, portanto, 8 bits por canal)
  • clear(DWORD c) preenche a imagem com a cor c

A color é apenas a union de DWORD dd e BYTE db[4] para access simples ao canal.

A List<> é o meu modelo (matriz dinâmica / lista>

  • List a é o mesmo que int a[] .
  • add(b) adiciona b a ele no final da lista
  • num é o número de itens na lista

Agora, para evitar muitos pontos (para o tempo de vida de sua causa de plotadora), você pode usar padrões de linha diferentes, etc., mas isso requer muito teste / erro ... Por exemplo, você pode contar quantas vezes uma cor é usada em alguma área e dessa razão usam padrões de preenchimento diferentes (baseados em linhas). Você precisa escolher entre qualidade de imagem e velocidade de renderização / durabilidade ...

Sem mais informações sobre seus resources de plotadora (velocidades, método de troca de ferramentas, comportamento de combinação de colors) é difícil decidir o melhor método de formar o stream de controle. Minha aposta é que você mude as colors manualmente para que você possa renderizar cada cor de uma só vez. Portanto, extraia todos os pixels com a cor da primeira ferramenta mesclar pixels adjacentes a linhas / curvas e renderizar ... depois, mova para a próxima cor da ferramenta ...