Pixles por mm en una imágen

[rochi]

Hola, la 'medida real' la mido sobre la imágen real, a priori de escanear la imágen. Luego marco los puntos correspondiente al segmento medido, y asi calculo la escala (x distancia en pixels -> distenMM). Esa es la forma rústica de hacerlo, pero quiero sacar esta responsabilidad del usuario, y obtenerla desde el bmp propiamente dicho. Buscando encontré GetDeviceCaps una función de las APIs que puede dar la cantidad de pixels o mm vertical y horizontal del dispositivo en cuestión, en mi caso, la imágen.

Si alguien sabe como...

Saludossss

[[seoane]]

Bien, escaneas la imagen. Cuando la escaneas la pasas directamente al programa o la guardas primero en un bmp. Si es lo segundo puedes usar este código:

Código Delphi [-]
procedure GetBitmapInfo(Filename: string; var Info: BITMAPINFOHEADER);
begin
  FillChar(Info,Sizeof(Info),0);
  with TFileStream.Create(Filename,fmOpenRead,fmShareDenyWrite) do
  try
    Seek(Sizeof(BITMAPFILEHEADER),soFromBeginning);
    ReadBuffer(Info,Sizeof(Info));
  finally
    Free;
  end;
end;

// Por ejemplo
var
  Info: BITMAPINFOHEADER;
  Str: string;
begin
  GetBitmapInfo('c:\1.bmp',Info);
  Str:=
    'Ancho = ' + IntToStr(Info.biWidth) + #13 +
    'Alto = ' + IntToStr(Info.biHeight) + #13 +
    'Profundidad en bits = ' + IntToStr(Info.biBitCount) + #13 +
    'Resolucion horizontal = ' + IntToStr(Info.biXPelsPerMeter) + ' Pixeles por metro' + #13 +
    'Resolucion vertical = ' + IntToStr(Info.biYPelsPerMeter) + ' Pixeles por metro' + #13;
  case Info.biCompression of
    BI_RGB: Str:= Str + 'Compresion = Sin comprimir';
    BI_RLE8: Str:= Str + 'Compresion = RL8';
    BI_RLE4: Str:= Str + 'Compresion = RLE4';
    BI_BITFIELDS: Str:= Str + 'Compresion = BITFIELDS';
  end;
  ShowMessage(Str);
end;

si te fijas uno de los parámetros que podemos obtener del bitmap son los "Píxeles por metro", que creo que es lo que estas buscando.

¿Te sirve o buscamos por otro lado?

[rochi]

Muchas gracias seoane, voy a estudiar ese código (desconozco BITMAPINFOHEADER).

Si estoy trabajando con archivos .bmp.

Creo que ya se donde estaba mi error, mi escaso conocimiento de las funciones API tiene mucho que ver. GetDeviceCaps transforma pixels a mm, pero mm de pantalla, que no necesariamente se corresponden con los mm medidos en la imágen sin digitalizar.

O sea que lo que estaba haciendo no tiene sentido si no tengo medidas 'reales'. Ya miro el código para ver si por ahi sale el asunto.

saludos, rochi

[rochi]

Hola, no solucionó mi problema, es mas me da mas lejos de lo real, en la versión anterior, al menos obtenía la dist. en mm sobre la pantalla y era correcta. Ahora, ni eso.
Estoy usando una función que retorna elBITMAPINFOHEADER, supuestamente tengo los pixels por metro, ¿metro medido sobre qué?.

Aqui dejo el código:

Código Delphi [-]
Var
  pto1,pto2:TPuntoVisual;

  pixelXpormetro,pixelYpormetro:Integer;

  distXpixel,distYpixel: Double;
  distXmm,distYmm: Double;  
  pixelXpormm,pixelYpormm: Double;
  
Begin

   //función que obtiene dato de tipo BITMAPINFOHEADER    
   getResolucionBitMap(pixelXpormetro,pixelYpormetro);

   // Convierto a cantidad de Pixels por mm    
   pixelXpormm := 0.001*pixelXpormetro;
   pixelYpormm := 0.001*pixelYpormetro;

   imgHdl := fact.getInstanceImgHndl;
   pto1 := imgHdl.getPuntoVisual(p1);
   pto2 := imgHdl.getPuntoVisual(p2);

   // deltaX = Abs(pto1.x - pto2.x)
   distXpixel := deltaPixels(pto1.x,pto2.x);
   distYpixel := deltaPixels(pto1.y,pto2.y);

       
   // Paso la distancia en pixels a mm
   distXmm := distXpixel/pixelXpormm;
   distYmm := distYpixel/pixelYpormm;

  
   // A mm milímetros le corresponden distPixels, distancia = formula Pitágoras

   imgHdl.DistPixels := distancia(distXpixel,distYpixel);
   imgHdl.Distmm := distancia(distXmm,distYmm);
   imgHdl.FactorEscala := (imgHdl.Distmm/imgHdl.DistPixels)*(1.0);
End;

Si alguien sabe que puede pasar, gracias...

[rochi]

Hola, que tal? bueno, al final resolví el problema como lo hacía originalmente,

1. marco 3 puntos en la imagen digitalizada p1,p2,p3 , de modo que formen un angulo recto, p1p2 paralelo al eje Ox y p2p3 al eje Oy.
2. Ingreso la distancia real en mm entre p1p2 y p2p3.
3. Calculo la distancia de esos segmentos en pixels, y como la equivalente en mm es conocida por mi (ingresada) obtengo un factor en X y factor en Y.
4. A cada distancia punto, le multiplico sus cooords. por el factor en X y en Y para obtener el equivalente en mm.

Asi funciona correctamente, medidas de angulos, rectas, proyecciones, etc.
Duda que tengo, mi imagen es un Bitmap, que está dentro de un TImage.
Cambié la resolución de pantalla, y noté que el ancho y alto del objeto TImage y del TBitmap permanecen constantes => los factores de conversión en X y en Y tampoco cambian, aun cuando cambia el valor de Screen.PixelsPerInch. ¿A que se debe eso?
¿El dfm tiene esa información y la usa independientemente de la resolución de la pantalla adaptando (distorcionando) la imagen?
¿Debo controlar la resolución para que no cambie la escala? (aunque no parece haber riesgo).
Entro otras cosas me interesa porque no se si ademas de guardar los factores en X y en Y por imagen, deba guardar la resolución a la que fue hallada.


Saludos, gracias

rochi

[rochi]

Me autorespondo, por si le sirve a alguien. Efectivamente la cantidad de pixeles del .bmp no cambia al cambiar la resolución ya que está guardada en el propio bitmap (y en el .dfm si la imagen está en el form).
Asi como el .dfm también guarda información del objeto TImage, que tampoco altera sus dimensiones al cambiar la resolución.

saludos, ro