Administración remota!!

[acertij022]

Hola amigos delphinos me encuentro entre la espada y la pared, les comento para entrar en tema.Estoy continuamente trabajando remotamente instalando y configurando maquinas de clientes pero me suele pasar que mis clientes o le parece muy dificil decime su IP o Passord (VNC) para ingresar remotamente o peor no saben como abrir algun puerto TCP para realizar la conexion, gracias a este dolor de cabeza estoy diseñando algo parecido a un VNC con algunas mejoras administativa, la idea que tengo es que el cliente se conecte a la mesa de ayuda por medio de un ejecutable para chatear y si fuese necesario poder ingresar a la pc para realizar la reparcion o configuracion.
Para evitar el Firewall se me ocurrio que la aplicacion funcione inversamente que el VNC o sea el cliente tiene un socket cliente y yo un server (emularia un browser o saldria por el port 21)hasta ahi cerramaba pero ahora necesitaba enviar una imagen de la pc y actualizar solo los pixeles que cambiaban utilizando el siguiente codigo:
para tomar una imagen:

Código Delphi [-]
procedure TFServer.GetDesktop(Imagen:integer);
var
        imag: TImage;
        jpg: TJpegImage;
        desktop: TCanvas;

begin
        imag:=TImage.Create(FServer);
        imag.Width:=screen.Width;
        imag.Height:=screen.Height;
        desktop:=TCanvas.Create;
        with DeskTop do
                Handle := GetWindowDC (GetDesktopWindow) ;

        with Imag.Canvas do
                CopyRect (Rect (0, 0, screen.Width, screen.Height),DeskTop,Rect (0, 0, screen.Width, screen.Height));
        jpg:=TJPegImage.Create;
        jpg.Assign(imag.Picture.Bitmap);
        imag.Free;
        jpg.CompressionQuality:=80; //Calidad del JPEG
        jpg.Compress;      //Comprimimos la imagen
        jpg.SaveToFile(IntToStr(Imagen)+'.jpg');
        jpg.Free;
        desktop.Free;
end;

Y para tomar las diferencias:

Código Delphi [-]
procedure comparar();
var
jpg: TJpegImage;
bmp1,bmp2: TImage;
int1,int2,int3:integer;
FInteger: file of integer;
begin
if (not fileexists('1.jpg'))or(not fileexists('2.jpg')) then exit;
bmp1:=TImage.Create(FServer);
jpg := TJpegImage.Create;
 try
 jpg.LoadFromFile('1.jpg');
 bmp1.Picture.Bitmap.Assign(jpg);    // Carga la imagen como BMP
 finally
 jpg.Free;
 end;

bmp2:=TImage.Create(FServer);
jpg := TJpegImage.Create;
 try
 jpg.LoadFromFile('2.jpg');
 bmp2.Picture.Bitmap.Assign(jpg);    // Carga la imagen como BMP
 finally
 jpg.Free;
 end;

AssignFile(FInteger,'3.int');
Rewrite(FInteger);
  // Recorrer la imagen
  for int1 := 0 to (bmp1.Picture.Bitmap.Height - 1) do
  begin
    for int2 := 0 to (bmp1.Picture.Bitmap.Width - 1) do
      begin
      // Diferentes
      if (bmp1.Picture.Bitmap.Canvas.Pixels[int2,int1] <>
          bmp2.Picture.Bitmap.Canvas.Pixels[int2,int1]) then
          begin
          // guardo las diferencias
          int3:=bmp2.Picture.Bitmap.Canvas.Pixels[int2,int1];
          Write(FInteger,int3);//valor del color del pixel
          Write(FInteger,int2);// posicion X
          Write(FInteger,int1);// posicion Y
          end;
      end;
  end;
CloseFile(FInteger);
bmp1.Free;
bmp2.Free;
end;

pero noto que las imagenes generadas pesan 112Kb y el archivo de diferencias pesan mas que la imagen y que el recorrido de pixel a pixel es muy lento.

A Alguien se le ocurre como optimizar el codigo o como puedo interactuar con las DLL del VNC
Desde ya muchas gracias

[[seoane]]

Antes de meternos a reinventar la rueda, puedes usar alguna solución como UltraVNC SC. En este hilo se hablo de este tema, y se llego a una solución a prueba de tontos

Software Control Remoto, sin abrir puertos en routers

Aunque si sigues queriendo hacerlo tu, te recomiendo un par de cosas. Primero, trabaja sobre imágenes bmp aunque luego las vayas a enviar como jpg, comparar dos jpeg puede ser problemático. Segundo no utilices la propiedad pixels del canvas, utiliza la propiedad Scanline del Bitmap es mucho mas rápido.

[Casimiro Notevi]

Empezado por seoane

Antes de meternos a reinventar la rueda, puedes usar alguna solución como UltraVNC SC. En este hilo se hablo de este tema, y se llego a una solución a prueba de tontos

Software Control Remoto, sin abrir puertos en routers

Aunque si sigues queriendo hacerlo tu, te recomiendo un par de cosas. Primero, trabaja sobre imágenes bmp aunque luego las vayas a enviar como jpg, comparar dos jpeg puede ser problemático. Segundo no utilices la propiedad pixels del canvas, utiliza la propiedad Scanline del Bitmap es mucho mas rápido.

Y además, el UltraVNC lleva incorporado, entre otros, unos "botoncitos" muy útiles: chat para conversar con el cliente, una utilidad para enviar y recibir ficheros (justo lo que necesitas), etc.

No hay que abrir ningún puerto, ni saber ninguna IP, ni nada de nada, absolutamente cómodo y rápido

[[seoane]]

Aparte de lo dicho anteriormente, volvamos a tu pregunta original, por si a alguien le puede resultar útil. Yo enfocaría el problema de otra manera, en vez de mandar pixel a pixel, encontraría el rectángulo de la imagen que ha cambiado, lo copiara, lo comprimiría usando jpeg y lo mandaría junto con sus coordenadas. Por otro lado al recibirlo solo tendríamos que dibujar el rectángulo en las coordenadas indicadas. Al comprimir la imagen usando jpeg puede que obtengamos un feo efecto de borde, pero es un mal menor comparada con lo que ganamos en velocidad.

La ventaja son que al enviar un recuadro completo podemos usar formatos de compresión como jpeg, gif o png. La desventaja es que si la imagen tiene muchos cambios repartidos por toda la superficie, el cuadro resultante puede ser prácticamente del mismo tamaño que el original. Es decir, donde realmente se muestra eficaz es en imágenes donde los cambios están localizados en una parte concreta de la pantalla.

Vamos con un poco de código:

Código Delphi [-]
function Min(i,j: Integer): Integer;
begin
  if i < j then
    Result:= i
  else
    Result:= j;
end;

function Max(i,j: Integer): Integer;
begin
  if i > j then
    Result:= i
  else
    Result:= j;
end;

procedure Seleccionar(Bitmap1, Bitmap2: TBitmap; var R: TRect);
var
  P1, P2: PByte;
  i, j: Integer;
begin
  R.Right:= 0;
  R.Bottom:= 0;
  R.Left:= Min(Bitmap1.Width,Bitmap2.Width);
  R.Top:= Min(Bitmap1.Height,Bitmap2.Height);
  Bitmap1.PixelFormat:= pf24bit;
  Bitmap2.PixelFormat:= pf24bit;
  for j:= 0 to Min(Bitmap1.Height,Bitmap2.Height) - 1 do
  begin
    P1:= Bitmap1.ScanLine[j];
    P2:= Bitmap2.ScanLine[j];
    for i:= 0 to Min(Bitmap1.Width,Bitmap2.Width) - 1 do
    begin
      if not CompareMem(P1,P2,3) then
      begin
        R.Right:= Max(i,R.Right);
        R.Bottom:= Max(j,R.Bottom);
        R.Left:= Min(i,R.Left);
        R.Top:= Min(j,R.Top);
      end;
      inc(P1,3); inc(P2,3);
    end;
  end;
end;

// Un ejemplo de como usar la funcion anterior:
var
  Bitmap1, Bitmap2, Bitmap3: TBitmap;
  R: TRect;
begin
  Bitmap1:= TBitmap.Create;
  Bitmap2:= TBitmap.Create;
  Bitmap3:= TBitmap.Create;
  try
    // Cargamos dos imagenes
    Bitmap1.LoadFromFile('d:\1.bmp');
    Bitmap2.LoadFromFile('d:\2.bmp');
    // Encontramos el recuadro donde estan localizados los cambios
    Seleccionar(Bitmap1,Bitmap2,R); 
    // Copiamos ese recuadro en un nuevo bitmap
    Bitmap3.Width:= R.Right - R.Left;
    Bitmap3.Height:= R.Bottom - R.Top;
    with Bitmap3 do
      Canvas.CopyRect(Rect(0,0,Width,Height),Bitmap2.Canvas,R);
    // En este ejemplo lo guardo, pero podriamos convertirlo a jpeg primero
    Bitmap3.SaveToFile('d:\3.bmp');
  finally
    Bitmap1.Free;
    Bitmap2.Free;
    Bitmap3.Free;
  end;
end;

Esta solución se puede mejorar bastante, un posible camino seria utilizar mas de un recuadro, mas pequeños, para localizar los cambios. Pero eso ya es otra historia ...

[acertij022]

Gracias a ambos pero intentare hacer lo que me dijo seoane (hacerlo desde delphi)ya que puedo agregar muchas mejoras administrativa como ser: si el cliente tiene deuda, toda la info del hardaware, chat,etc aunque tienen razon de que no hay que reiventar la rueda por eso en un momento comente como interactuar con las DLL

pd:Estoy muy contento de ser parte de este sitio las respuestas son increblemente rapidas y uno puede evaluar varias postura de una idea

[acertij022]

Hasta ahora solo logre esto pero nose como comparar y enviar solo la porcion que cambio

Código Delphi [-]
nit UServer;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls, Jpeg, IdBaseComponent, IdComponent,
  IdTCPConnection, IdTCPClient;

type
  TFServer = class(TForm)
    Timer1: TTimer;
    tcp: TIdTCPClient;
    procedure GetDesktop(Imagen:integer);
    procedure Timer1Timer(Sender: TObject);
    procedure Enviar(Imagen:integer);

  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  FServer: TFServer;
  streamBMP1,streamBMP2:TMemoryStream;
  BMPEstado:integer=0; //indica que imagen esta para comparar

implementation

{$R *.dfm}
//##############################################################################
procedure TFServer.GetDesktop(Imagen:integer);
var
imag: TImage;
desktop: TCanvas;
begin
imag:=TImage.Create(FServer);
imag.Width:=screen.Width;
imag.Height:=screen.Height;
desktop:=TCanvas.Create;
with DeskTop do Handle := GetWindowDC (GetDesktopWindow) ;
with Imag.Canvas do CopyRect (Rect (0, 0, screen.Width, screen.Height),DeskTop,Rect (0, 0, screen.Width, screen.Height));
desktop.Free;
if Imagen=1 then
   begin
   streamBMP1:=TMemoryStream.Create;
   imag.Picture.Bitmap.SaveToStream(streamBMP1);
   end;
if Imagen=2 then
   begin
   streamBMP2:=TMemoryStream.Create;
   imag.Picture.Bitmap.SaveToStream(streamBMP2);
   end;
imag.Free;
end;
//##############################################################################
function comparar():boolean;
begin
Result:=true;
if streamBMP1<>streamBMP2 then Result:=true;
end;
//##############################################################################
procedure TFServer.Timer1Timer(Sender: TObject);
begin
Application.ProcessMessages;
if BMPEstado=0 then
   begin
   GetDesktop(1);
    try
    tcp.Connect;
    except Timer1.Enabled:=false; exit; end;
   Enviar(1);
   BMPEstado:=2;
   end;
if BMPEstado=1 then
   begin
   GetDesktop(1);
   if not comparar then
     begin
      try
      tcp.Connect;
      except Timer1.Enabled:=false; exit; end;
     Enviar(1);
     streamBMP2.Free;
     BMPEstado:=2;
     end
   else streamBMP1.Free;
   end;
if BMPEstado=2 then
   begin
   GetDesktop(2);
   if not comparar then
     begin
      try
      tcp.Connect;
      except Timer1.Enabled:=false; exit; end;
     Enviar(2);
     streamBMP1.Free;
     BMPEstado:=1;
     end
   else streamBMP2.Free;
   end;
end;
//##############################################################################
procedure TFServer.enviar(Imagen:integer);
begin
 try
  with tcp do
    begin
    OpenWriteBuffer;
    if Imagen=1 then WriteStream(streamBMP1);
    if Imagen=2 then WriteStream(streamBMP2);
    CloseWriteBuffer;
    Disconnect;
    end;
 except end;
end;
//##############################################################################
end.