Scanear Imagem

[Guest - Vagner -]

Gostaria de escanear uma determinada imagem, como um cartão da mega-sena, setar as coordenadas e vazer a verificação da cor que está nesta coordenada ?

alguém tem alguma idéia

[Churc]

opa

eu mexi com isso uma vez quando eu tava tentando fazer um VNC

inclusive postei aqui no fórum... deu certo o scaneamento mas errado

o que eu queria fazer rsr

Essa primeira função, o Bitmap precisa ter 24 bits de cores, pra conseguir

pegar o R.G.B separadamente, isso seria pra scaneamento de "alta precisão".

vou passar do jeito que usei, ai você adapta a sua necessidade...

procedure CreateFrameBuffer(const BitmapA, BitmapB: TBitmap);
type
  TRGBTripleArray = array[Word] of TRGBTriple;
  pRGBTripleArray = ^TRGBTripleArray;
  TTransmittedPixel = record
    RGB: DWORD;
    Pos: TPoint;
  end;
var
  x, y: Integer;
  RowA, RowB: pRGBTripleArray;
  NetBuff: TTransmittedPixel;
begin
  for y := 0 to BitmapA.Height -1 do
  begin
    RowA := BitmapA.Scanline[y];
    RowB := BitmapB.Scanline[y];
    for x := 0 to BitmapA.Width -1 do
    begin
      if (RGB(rowA[x].rgbtRed, rowA[x].rgbtGreen, rowA[x].rgbtBlue) <>
          RGB(rowB[x].rgbtRed, rowB[x].rgbtGreen, rowB[x].rgbtBlue)) then
      begin
        //NetBuff.RGB := TColor(RGB(rowB[x].rgbtRed, rowB[x].rgbtGreen, rowB[x].rgbtBlue));
        //NetBuff.RGB := BitmapB.Canvas.Pixels[x, y];
        NetBuff.RGB := GetPixel(BitmapB.Canvas.Handle, x, y);
        NetBuff.Pos.X := x;
        NetBuff.Pos.Y := y;
        //Form1.Image1.Canvas.Pixels[NetBuff.Pos.X, NetBuff.Pos.Y] := NetBuff.RGB;
      end;
    end;
  end;
end;

O que eu fazia nesta função é scanear um bitmap, que era uma screenshot atual e outra screenshot anterior verificando as cores que estavam diferentes e assim enviar ao servidor apenas os pixels que eram diferentes da screenshot anterior, na minha ideia era como o VNC fazia, mas não é isso que ele faz rsr... mas pra você vai ser útil... essa outra função faz a mesma coisa, só que em um bitmap com 8 bits (256 cores) isso no meu caso era bom pra ser mais rápido... acho que no seu caso, é melhor de 24 bits, de qualquer forma, o que ela faz é pegar uma ScreenShot da tela e fazer o mesmo que a função acima, porém a função acima tinha que ser passado os bitmaps para verificação, essa compara com um bitmap armazenado numa variavel global... você precisa ajustar pra como quer fazer...

procedure CreateFrameBuffer2;
var
  x, y: Integer;
  RowA, RowB: pByteArray;
  NetBuff: TTransmittedPixel;
  Frame: TBitmap;
  temp: TBitmap;
begin
  if (i >= 10) then Exit;
  
  Frame := TBitmap.Create;
  temp := TBitmap.Create;

  Frame.Width := GetSystemMetrics(SM_CXSCREEN);    {Screen.Width }
  Frame.Height := GetSystemMetrics(SM_CYSCREEN);   {Screen.Height}

  temp.Width := Frame.Width;
  temp.Height := Frame.Height;

  BitBlt(Frame.Canvas.handle, 0, 0, Frame.Width, Frame.Height, GetDc(0), 0, 0, SRCCOPY);

  Frame.PixelFormat := pf8bit;
  temp.PixelFormat := pf8bit;

  if (Frame.Empty) then
  begin
    PreviousFrame.Assign(Frame);
    Frame.Free;
    Exit;
  end;
  
  for y := 0 to PreviousFrame.Height -1 do
  begin
    RowA := PreviousFrame.Scanline[y];
    RowB := Frame.Scanline[y];
    for x := 0 to PreviousFrame.Width -1 do
    begin
      if (RowA^[x] <> RowB^[x]) then
      begin
        NetBuff.RGB := Frame.Canvas.Pixels[x, y]; //venceu na temporizacao
        //NetBuff.RGB := GetPixel(BitmapB.Canvas.Handle, x, y);
        NetBuff.Pos.X := x;
        NetBuff.Pos.Y := y;
        //Form1.Image1.Canvas.Pixels[NetBuff.Pos.X, NetBuff.Pos.Y] := NetBuff.RGB;
        temp.Canvas.Pixels[NetBuff.Pos.X, NetBuff.Pos.Y] := NetBuff.RGB;
      end;
    end;
  end;
  temp.SaveToFile('bla' + IntToStr(i) + '.bmp');
  i := i + 1;
  PreviousFrame.Assign(Frame);
  Frame.Free;
  temp.Free;
end;

da uma olhada se tiver dúvida posta ai que a gente te ajuda...

abraço

[Guest Visitante]

Amigo, como faço para utilizar esta função ?

[vagner.oliveira]

Amigo, como faço para utilizar esta função ?

É como se fosse um cartão da mega-sena, vai ter os quadrados e o usuario irá completar todo ele. Depois o programa irá ler esta coordenada e verificar se está preenchida.

[Churc]

opa

Bom, esse cartão terá que ser sempre igual, a não

ser que você faça um mapeamento pra cada cartão.

Você irá precisar mapear o cartão, pro seu programa

saber qual as coordenadas X e Y em que contém um

quadrado, ou seja, o quadrado que será marcado.

Você pode usar o paint pra isso, repare que quando

você passa o mouse emcima da imagem, ele mostra

na barra de status a posição X e Y, tipo 21,5 onde

21 = posição X, horizontal

5 = posição Y, vertical

Com a imagem mapeada, ou seja, você já tem todas

as faixas de onde estão os quadrados, ai você vai scanear

a imagem e comparar as cores, por exemplo, vamos supor

que o cartao é branco, certo, quando você scanear a imagem

você terá de verificar se a posição X e Y do Scaneamento está

dentro de alguma faixa de um quadrado, e enquanto tiver na

faixa do quadrado, se a cor RGB não foi branca então o usuário

marcou aquele quadrado... você pode criar um limite também

(offset) por exemplo, se você fizer pra ser 1 pixel não for branco

na faixa do quadrado, isso pode complicar, pois se o cartão tiver

empoeirado? então você faria algo do tipo se mais de 5 pixels

estiverem de cor diferente de branco ai está marcado o quadrado.

o que vai salvar pra você na funcao acima é só o scaneamento...

vamos supor que você carregou o cartao em uma variavel de

Bitmap chamada MeuCartao: TBitmap;

type
  TRGBTripleArray = array[Word] of TRGBTriple;
  pRGBTripleArray = ^TRGBTripleArray;
var
  x, y: Integer;
  RowX, RowY: pRGBTripleArray;
begin
  //Scaneia a Vertical da Imagem
  for y := 0 to MeuCartao.Height -1 do
  begin
    RowY := MeuCartao.Scanline[y];
    //Scaneia a Horizontal da Imagem
    for x := 0 to MeuCartao.Width -1 do
    begin
      RowX := MeuCartao.Scanline[x];
      //Crie uma função que checa as coordenadas da imagem se está
      //dentro das coordenadas do quadrado...
      if (inRange(X, Y) then
      if (TColor(RGB(rowA[x].rgbtRed, rowA[x].rgbtGreen, rowA[x].rgbtBlue)) <> clWhite) then
      begin
        //Crie uma função que identifique qual quadrado está entre
        //estas coordenadas, você pode usar um Type e criar uma array
                                //armazenando as coordenadas dos quadrados
        ShowMessage(GetCheckID(X, Y));
       end;
     end;
  end;
end;

Tipo, não que você vai se aproveitar dessa função é

apenas pra você ter uma base, eu estou sem delphi aqui montei

visualizando as de cima... assim que eu puder, se ninguém te passar

um exemplo ou se você não conseguir eu monto um exemplo

pra você, está meio corrido aqui no trampo =\

abraço