eqalign-devel — Lista de correo de desarrollo EQALIGN

[Eqalign-devel] Camaras detectadas en el menu

[Antonio F. <ant...@ya...>]

Pues eso, he tocado la clase gen=E9rica Camera para que detecte las =
c=E1maras WDM, QHY y Atik disponibles.
B=E1sicamente trato de conectarlas mediante el propio driver, si se pudo =
conetar la a=F1ado a la lista y la desconecto. Luego esa lista las =
maneja el propio mainform para ofrecerlas en el men=FA.
Qu=E9 pena no tener mi atik a mano, Francisco comenta si funciona, no =
s=E9 si se me qued=F3 algo de la implementaci=F3n de la nueva WDMCam en =
las Atik16 y QHY5Cam.=20
En principio ahora se puede reescribir GetFrame de las WDM para que sea =
m=E1s =F3ptimo en modo video real, no hace falta que la imagen la =
capture el hilo Exposure si no es larga exposici=F3n. S=F3lo lo hice =
as=ED para comprobar si el m=E9todo funcionaba bien para las QHY y las =
Atik.

Francisco, lo dicho: comenta si la implementaci=F3n va bien y entonces =
ya podemos excluir de la soluci=F3n las "antiguas" WDM y QHY5.

Un saludo

Re: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase completada

[Antonio F. <ant...@ya...>]

perd=F3n, el c=F3digo creo que deber=EDa ser este:

byte* dst =3D (byte*)bmData.Scan0.ToPointer();
byte* src =3D (byte*)image.Scan0.ToPointer();
int offsetdst =3D dstData.Stride - width * 3;
int offsetsrc =3D image.Stride - width;

for (int y =3D 0, idx =3D 0; y < height; y++)
{
    ushort* pDst =3D dst + y * width;
    ushort* pSrc =3D src + y * width;
    for (int x =3D 0; x < width; x++, pDst++)
    {
        ushort v =3D *pSrc++;

        byte b =3D (byte)v;
        *pDst ++ =3D b;
        *pDst ++ =3D b;
        *pDst =3D b;
    }
    pDst +=3D offsetdst;
    pSrc +=3D offsetsrc;
}


No s=E9, deber=EDas probarlo.

Un saludo!
  ----- Original Message -----=20
  From: Antonio Fraga=20
  To: Lista de correo de desarrollo EQAlign=20
  Sent: Tuesday, October 09, 2007 7:21 PM
  Subject: Re: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase =
completada


  Sem=E1foros... no soy un experto en paralelismo, pero creo que est=E1 =
funcionando de perlas. Tuve un problema al verlo con la webcam =
modificada: m=E1s que a menudo, cuando se invocaba el m=E9todo GetFrame =
la imagen no estaba disponible porque la variable booleana imgready =
estaba a false (la hab=EDa puesto a false el hilo de Exposure) aunque =
s=ED que hab=EDa una imagen disponible.
  Creo que est=E1n bien implementados, los he incluido en QHY5Cam, =
Atik16 y WDMCam, no puedo probar la Atik16 porque no la tengo, as=ED que =
deber=EDas comprobarlo en la QHY5.
  Todav=EDa falta recopilar la lista de c=E1maras activas y dem=E1s, me =
pongo a ello.
  Francisco, tengo una duda con el m=E9todo Bitmap24FromUnmanagedCode:

  for (int y =3D 0; y < bmp.Height; y++)
  {
  CopyMemory(dest, source, len);
  source =3D new IntPtr(source.ToInt32() + len);
  dest =3D new IntPtr(dest.ToInt32() + bmData.Stride);
  }

  la imagen de destino es de 3 bytes (1 byte por canal) y la imagen =
original de 1 byte, si copias CopyMemory(dest, source, len);, s=F3lo =
deber=EDas tener iformaci=F3n en el primer tercio de la imagen =BFno?, =
creo que el c=F3digo deber=EDa ser algo as=ED como:

  byte* dst =3D (byte*)bmData.Scan0.ToPointer();
  byte* src =3D (byte*)image.Scan0.ToPointer();
  int offsetdst =3D dstData.Stride - width * 3;
  int offsetsrc =3D image.Stride - width * 3;

  for (int y =3D 0, idx =3D 0; y < height; y++)
  {
      ushort* pDst =3D dst + y * width;
      ushort* pSrc =3D src + y * width;
      for (int x =3D 0; x < width; x++, pDst++)
      {
          // single input channel (greyscale)
          ushort v =3D *pSrc++;

          byte b =3D (byte)val;
          *pDst ++ =3D b;
          *pDst ++ =3D b;
          *pDst =3D b;
      }
      pDst +=3D offsetdst;
      pSrc +=3D offsetsrc;
  }

  pero deber=EDas comprobarlo.

  Bueno, pues un saludo!
    ----- Original Message -----=20
    From: Antonio Fraga=20
    To: Lista de correo de desarrollo EQAlign=20
    Sent: Tuesday, October 09, 2007 3:09 PM
    Subject: Re: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase =
completada



    Buf!, un rollo patatoso! He modificado las especificaciones de =
CameraInterface:

    Propiedades p=FAblicas:
    string Driver  nombre del dispositivo
    bool IsConnected informa si la c=E1mara est=E1 conectada
    int Width  ancho de la imagen=20
    int Height  alto de la imagen
    Rectangle SubframeRegion region del subframe=20
    bool Subframe devuelve/establece el modo de subframa
    int ExposureTime tiempo de exposici=F3n (s=ED, como propiedad)
    eCameraReadOutMode ExposureMode modo de exposici=F3n (lo vemos)
    bool ImageReady informa si hay una imagen diponible
    DateTime CronoStart informa del momento en que se efectivamente se =
inici=F3 la exposici=F3n (para sincronizar la barra de presentaci=F3n de =
crono)

    M=E9todos p=FAblicos:
    void Connect() trata de establecer la conexi=F3n con la c=E1mara
    void Disconnect() desconecta la c=E1mara
    void Settings() lanza el di=E1logo de settings
    void Config()  lanza el di=E1logo de configuraci=F3n   (lo siento en =
WDM Config y Settings son dos cosas distintas)
    Bitmap GetFrame() devuelve el =FAltimo fotograma disponible.

    Adem=E1s hay que tener en cuenta que cuando se sirve al =FAltimo =
fotograma el buffer interno se vac=EDa: fotograma servido/fotograma =
perdido. Esto es as=ED para que el sistema de autoguiado (en caso de =
p=E9rdida de fotograma) no piense que no hay efectos sobre un comando =
gu=EDa.

    Sobre el modo de exposici=F3n. Un rollo, a ver si no me enrollo:
    Por una parte no interesa que el sistema est=E9 esperando en un =
bucle por una exposici=F3n, por eso antes el control de usuario era =
quien establec=EDa el inicio de exposici=F3n, controlaba el crono y =
luego cerraba la exposici=F3n; mientras ocurre todo esto, el sistema =
sigue activo.

    Pero tanto la Atik16, como la QHY (y probablemente todas las =
demaisss), el tiempo de exposici=F3n se establece en la llamada y luego =
hay que estar pendiente hasta que la imagen est=E1 disponible.

    Vale, soluci=F3n de en medio:
    Cuando la c=E1mara se conecta, se crea un hilo de exposici=F3n:
              //hilo de exposici=F3n
              ThExpose =3D new Thread(new ThreadStart(Exposure));
              ThExpose.TrySetApartmentState(ApartmentState.STA);
              ThExpose.Start();

    Este hilo est=E1 haciendo, en un loop "infinito" exposiciones =
continuas de tiempo (exposureTime), el hilo se queda esperando hasta que =
la imagen est=E1 disponible y entonces la carga en la propiedad privada =
Bitmap bmp.

    GetFrame, simplemente comprueba que la c=E1mara est=E1 conectada, =
que la propiedad bmp no es nula y que la imagen est=E1 disponible (por =
si acaso tambi=E9n que no estamos en un momento cr=EDtico: se est=E1 =
leyendo la imagen). En esos casos devuelve bmp.Clone() y libera bmp =
(fotograma servido, fotograma perdido).

    Para probar que todo esto funciona:
    -(y no perder el antiguo driver WDM) he reescrito otro driver WDMCam =
que se comporta de este modo. Simplemente tambi=E9n porque no tengo la =
Atik (est=E1 en el taller de reparacioones) as=ED que quer=EDa probar el =
tema de hilos con la webcam
    -he incorporado un driver m=EDnimo para la atik16
    -(para no perder QHY tal como estaba) he redise=F1ado QHYCam =
(copia/pega) para que cumpla el interfaz. Sobre QHY, cuidado, s=F3lo he =
a=F1adido las propiedades m=EDnimas del interfaz que debe cumplir para =
que compile.

    No lo he podido comprobar con la webcam modificada para LX, s=ED con =
una webcam CMOS barata.

    Vale uno de los problemas que me encontr=E9 era la sincronizaci=F3n =
entre el timmer de exposici=F3n del control de usuario y la =
disponibilidad efectiva de la imagen. Para minimizar las diferencias, =
a=F1ad=ED la propiedad CronoStart, que cada c=E1mara debe establecer =
como DateTime.Now justo antes de lanzar la larga exposici=F3n. A=FAn =
as=ED sigue habiendo alguna discrepancia que crea un efecto un poco =
raro, pero no se me ocurre otra cosa (excepto eliminar el progressBar)

    Esa es una. Otra es el modo de lectura:
      public enum eCameraReadOutMode
      {
        ContinueShortMode =3D 0,
        LXContinueMode,
        SingleShoot
      };

    Vamos, el modo ContinueShortMode en WDM es video en tiempo real, =
LXContinueMode es exposici=F3n LX cont=EDnua y SingleShoot, un solo =
"disparo" (no creo que tenga utilidad, excepto APRA las c=E1maras de =
luz)
    En WDM ok, pero para las QHY /Luna. Bien!! El tiempo de captura de =
una imagen no es muy largo, entonces podremos hacer algo as=ED como =
exposiciones de corto periodo para ir simulando un RealTimeVideo, ese =
ser=EDa el modo ContinueShortMode. No hay ninguna diferencia con =
respecto a LXContinueMode!!!! Es lo mismito. En este caso habr=E1 que =
establecer el tiempo de exposici=F3n a algo as=ED como 100ms y listo (lo =
hace el driver al establecer la propiedad ExposureMode).

    Tambi=E9n est=E1 el tema de Subframe y SubframeRegion. La Atik lo =
permite aunque todav=EDa no me funcionaba (cuando me venga de vuelta, lo =
retomar=E9).

    Me imagino que en las QHY s=F3lo hay que llamar a:
    uint ms =3D ProgramCamera(subframeregion.X, subframeregion.Y,=20
     ubframeregion.Width, subframeregion.Height,=20
     (int)convertGain(255));

    , as=ED lo puse en el m=E9todo set de la propiedad (despu=E9s de =
comprobar si la regi=F3n  es v=E1lida)

    En fin, como no tengo la Atik no puedo hacer pruebas. Si hay otras =
ideas pues a contar!!! Lo he implementado lo m=E1s r=E1pidamente posible =
para que no afecte al actual desarrollo de la beta y no he tocado WDM =
para poder tirar para atr=E1s.

    Otra cosa: ahora falta que Camera comience a hacer Connects a todo =
"quisque" para saber si est=E1 "presente" o no y poder construir la =
lista de c=E1maras disponibles. Luego MainWindow ya podr=EDa =
manej=E1rselas.. . si puedo lo hago esta noche.

    Y otra cosa, en la exposici=F3n (m=E9todo GetFrame) ten=EDais algo =
as=ED como:
    System.Drawing.Bitmap bmp =3D new System.Drawing.Bitmap(1280, 1024, =
format);
    System.Drawing.Imaging.BitmapData bmpData =3D bmp.LockBits(new =
System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), =
System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
    bmp.UnlockBits(bmpData);
    GETBUFFER(bmpData.Scan0, 1310720);

    // Obtenci=F3n del bitmap
    Bitmap bp =3D this.Bitmap24FromUnmanagedCode(bmpData.Scan0, 1280, =
1024);

    En QHYCam (recuerda que est=E1 en el m=E9todo Exposure que es un =
thread), lo he dejado as=ED:
    Bitmap bp =3D new System.Drawing.Bitmap(1280, 1024, format);
    BitmapData bmpData =3D bp.LockBits(new System.Drawing.Rectangle(0, =
0, bmp.Width, bmp.Height), =
System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
    GETBUFFER(bmpData.Scan0, 1310720);
    bmp =3D this.Bitmap24FromUnmanagedCode(bmpData.Scan0, 1280, 1024);
    bp.UnlockBits(bmpData);

    , la diferencia es que la l=EDnea bp.UnlockBits(bmpData), est=E1 =
despu=E9s de la llamada a Bitmap24FromUnmanagedCode. Mira si funciona, =
lo he hecho a ojo.

    Un saludo


    Francisco Jos=E9 <is...@ya...> escribi=F3:
      Hola Antonio!

      =BFSabes si han arreglado o tienen intenci=F3n de arreglar el tema =
de los 16 bits en .Net 3.0? En fin, sin comentarios... para trabajar con =
FITs, tambi=E9n tenemos FitsIO de la NASA =
(http://heasarc.gsfc.nasa.gov/docs/software/fitsio/) la usan muchos =
programas y est=E1 portada a varios sistemas operativos (Linux entre =
ellos), es software abierto aunque desconozco su licencia concreta.

      Sobre la QHY5 o Luna 1.3 o QGuider... pues va sobre USB 2.0, la =
descarga es muy r=E1pida y m=E1s a=FAn si trabajamos con subframes (es =
posible hacerlo), lo cual ser=EDa muy recomendable para el futuro.

      Hoy he subido un commit que resuelve un fallo en el control de =
ganancia de la c=E1mara, ha sido el propio Tom el que me lo ha =
corregido, la verdad, me alegro que haya cambiado tanto su =
comportamiento con nosotros, la c=E1mara est=E1 funcionando ahora =
perfectamente, me muero de ganas de verla en funcionamiento, tanto en la =
puesta en estaci=F3n como en el guiado, a ver si para este puente lo =
tenemos y me canso de hacer pruebas.

      Sobre las ideas que comentas, me parecen correctas, ten en cuenta =
que a la larga m=E1s y m=E1s c=E1maras ser=E1n a=F1adidas y la mayor=EDa =
tendr=E1n cron=F3metro interno, por mi parte, la siguiente en caer a no =
mucho tardar ser=E1 la Artemis, mas que para guiar (ser=EDa de g=E9nero =
absurdo usarla para eso), para poner en estaci=F3n, ser=E1 una gozada =
por el enorme campo que da.

      Ya me cuentas!

      Un saludo!


      ----- Mensaje original ----
      De: Antonio Fraga <ant...@ya...>
      Para: Lista de correo de desarrollo EQAlign =
<eqa...@li...>
      Enviado: lunes, 8 de octubre, 2007 18:34:58
      Asunto: Re: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase =
completada


      Hola Francisco!
      Pues mejor, 24bpp nos va a ahorrar algunos quebraderos de cabeza, =
sobre todo a la hora de dibujar el ret=EDculo.
      No s=F3lo Net2.0 sino el 1.0 (claro) tienen roto el modo 16bits. =
Por eso en su d=EDa evalu=E9 el proyecto FreeImage para trabajar a 16 =
bits. De todas maneras todav=EDa estamos en la fase de "C=E1mara =
gu=EDa", cuando lleguemos a "C=E1mara de luz" habr=E1 que plantearse =
guardar las im=E1genes en .FIT,  FreeImage no lo soporta, as=ED que =
tendremos que trabajar sobre el formato.

      Sobre la rapidez: =BFcu=E1nto tarda en descargarse una imagen =
completa?, me imagino que si no es USB2.0 tardar=E1 m=E1s de un par de =
segundos =BFno?
      En ese caso, como c=E1mara gu=EDa, lo ideal es se lo m=E1s =
r=E1pido posibles y eso se podr=EDa conseguir si el driver de la =
c=E1mara permite trabajar sobre "corps"

      Sobre el tiempo de exposici=F3n, lo mejor es aumentar el interfaz =
de c=E1mara y a=F1adir los m=E9todos LX. Tal como lo tenemos, el control =
de usuario de c=E1mara es el que cronometra el shutter, as=ED es como =
funcionan las webcam, pero el driver de las QHY, por lo que veo, tienen =
el crono interno y hay que especificarle en la llamada el tiempo de =
exposici=F3n.

      Podr=EDamos generalizarlo y ver c=F3mo encajan las webcamLX:

      para:
      StartLXMode
      StopLXMode
      las QHY no har=EDan nada, los implementan por compatibilidad

      el actual
      void startLXExposure(void)

      podr=EDa convertirse en=20
      void startLXExposure(int milliseconds)

      y en lugar de que el control de usuario de c=E1mara cronometre el =
tiempo de exposici=F3n, sea el propio startLXExposure quien lance un =
hilo.=20
      Actualmente el crono del control de usuario es el que termina la =
exposici=F3n cuando el tiempo se ha cumplido llamando a=20
      void stopLXExposure(void)

      este m=E9todo podr=EDa desaparecer y en su lugar, el hilo cuando =
termina la exposici=F3n se encargar=EDa de realizar el trabajo de =
stopLXExposure (en webcamLX) y lanzar un evento para informar que la =
imagen est=E1 disponible.

      S=F3lo hay que cambiar un par de cosas en:
      WDM.cs
      CameraInterface.cs
      UCCamControl.cs

      GetFrame() tal como est=E1 concebido s=F3lo se encargar=EDa de =
servir el =FAltimo fotograma almacenado, no de la exposici=F3n en s=ED, =
de eso se encargar=EDa:
      startLXExposure

      Excepto en modo video real, que s=ED se encarga de capturar la =
=FAltima imagen de la webcam.

      En las QHY, si el tiempo de descarga es peque=F1o (o si se puede =
trabajar con crops), entonces GetImage()  podr=EDa estar capturando en =
tiempos peque=F1os (0.1, 0.2, ... 0.5seg) configurables, tal como hace =
el actual WDM.

      Y sobre el men=FA de c=E1maras disponibles: Ok, Camera.cs debe =
capturar tanto la disponibilidad de c=E1maras WDM, como QHY y en el =
futuro DSI, Atik16IC, etc (jeje), para eso hay que modificar el m=E9todo =
GetDeviceList para que pregunte por la disponibilidad de cada c=E1mara =
que hayamos implementado. En la QHY b=E1sicamente habr=E1 que conectarla =
y desconectarla. Pero en lugar de mostrar mensajes, como haces ahora, =
deber=EDamos establecer un tipo enumerado con errores gen=E9ricos y =
devolver el error en una variable de status, de los mensajes ya ese =
encargar=E1n los "jefes" (por cierto habr=E1 que internacionalizar esos =
mensajes).

      >> Bueno, vaya mamotreto me ha quedado, lo dicho, gracias a los =
dos por la ayuda que me hab=E9is >> prestado, aunque mucho me temo que =
la volver=E9 a necesitar para mejorar el tema.

      =A1Venga ya! No me lo puedo creer :) p=E1-eso estamos aqu=ED =
=BFno?

      Bueno, d=E9jame un par de d=EDas para buscar c=F3mo las webcamLX =
(producto estrella hasta la llegada del driver QHY :) encajan con el =
nuevo modelo, esta noche lo tengo jo**do pero creo que ma=F1ana puedo =
dejarlo esbozado. Si hay alguna sugerencia o no est=E1n de acuerdo con =
el modelo ... a discutir!!!

      Un saludo
        ----- Original Message -----=20
        From: Francisco Jos=E9=20
        To: Lista correo EQAlign=20
        Sent: Monday, October 08, 2007 12:39 AM
        Subject: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase =
completada


        Pues el soporte preliminar de las QHY5 y derivadas ya est=E1 en =
el repositorio de EQAlign, como podr=E9is ver, al final y tras =
much=EDsimas pruebas me he decidido a trabajar directamente en 24bpp:
         - .NET 2.0 s=F3lo soporta 8 bits (que creo ser=EDa lo m=E1s =
eficiente) en modo indexado y en color, con lo que habr=EDa que =
transformar a escala de grises empleando recursos, lo que ganamos por un =
lado se pierde por otro.
        - .NET 2.0 tiene rotos todos los formatos de imagen de 16 bits, =
sabido es mi cari=F1o por los creadores del framework, de modo que evito =
comentarios que puedan resultar hirientes; en definitiva, descartado =
tambi=E9n.
        - Lo =FAnico que da buen resultado es trabajar directamente a =
24bpp, la c=E1mara puede retornar una imagen de este formato, y aunque =
pueda resultar un desperdicio de memoria he comprobado que es lo m=E1s =
r=E1pido al no tener que realizar transformaciones adicionales, esa es =
la soluci=F3n que he adoptado. No obstante ah=ED est=E1 el c=F3digo, lo =
pod=E9is modificar a vuestro antojo.

        Aunque el driver que implementa la interfaz CameraInterface =
est=E1 lista, quedan ciertos detalles para pulirla, a saber:
         - Necesito conocer el tiempo de exposici=F3n justo cuando se =
lanza =E9sta, con lo que de alguna manera habr=E1 que comunic=E1rselo al =
driver, tal y como est=E1 ahora dise=F1ado el sistema no lo veo trivial; =
podr=E9is ver que actualmente es el procedimiento GetFrame() el que =
realiza las tareas de:
               -  Lanzar la exposici=F3n (en un hilo)
               - Esperar a que termine la exposici=F3n..
               - Retornar la imagen (Bitmap)

        Sobre esto, una duda, cuando EQAlign lance la exposici=F3n =
=BFquedar=E1 bloqueado a la espera de que GetFrame() retorne la imagen?, =
Antonio, com=E9ntame si es as=ED. Como ves, el modo de funcionamiento de =
la c=E1mara es "iniciar exposici=F3n -> esperar -> obtener imagen", no =
tiene sentido un stopLx() o similar.=20

        Por compatibilidad con WDM he implementado las principales =
funciones LX de las webcams, pero como te digo, es que con el modo de =
funcionamiento de esta c=E1mara no les veo el sentido en este driver. La =
idea ser=EDa que lanzara una llamada no bloqueante a GetFrame cada x =
periodo de tiempo.

        Para concluir, falta la integraci=F3n final; no he querido =
tocar, por que es muy tarde y el sue=F1o puede hacer que destroce algo, =
pero en la interfaz principal hay que a=F1adir la nueva c=E1mara:
            - Que el men=FA C=E1mara se active si se detecta la QHY5
            - En caso de tener QHY y adem=E1s un WDM, permitir =
seleccionar uno de los dos.

        Para ello, creo que, al menos, habr=E1 que modificar el =
procedimiento GetDeviceList() de Camera.cs para a=F1adir soporte a m=E1s =
c=E1maras; y m=E1s cosillas, si no es mucha molestia, Antonio, dime =
exactamente lo que es necesario realizar.

        Bueno, vaya mamotreto me ha quedado, lo dicho, gracias a los dos =
por la ayuda que me hab=E9is prestado, aunque mucho me temo que la =
volver=E9 a necesitar para mejorar el tema.

        Un saludo.



------------------------------------------------------------------------

        S=E9 un Mejor Amante del Cine
        =BFQuieres saber c=F3mo? =A1Deja que otras personas te ayuden! .

        =
-------------------------------------------------------------------------=

        This SF.net email is sponsored by: Splunk Inc.
        Still grepping through log files to find problems?  Stop.
        Now Search log events and configuration files using AJAX and a =
browser.
        Download your FREE copy of Splunk now >> http://get.splunk.com/=20
        _______________________________________________
        Eqalign-devel mailing list
        Eqa...@li...
        https://lists.sourceforge.net/lists/listinfo/eqalign-devel





-------------------------------------------------------------------------=
-

      S=E9 un Mejor Amante del Cine
      =BFQuieres saber c=F3mo? =A1Deja que otras personas te ayuden! .
      =
-------------------------------------------------------------------------=

      This SF.net email is sponsored by: Splunk Inc.
      Still grepping through log files to find problems? Stop.
      Now Search log events and configuration files using AJAX and a =
browser.
      Download your FREE copy of Splunk now >> =
http://get.splunk.com/_______________________________________________
      Eqalign-devel mailing list
      Eqa...@li...
      https://lists.sourceforge.net/lists/listinfo/eqalign-devel





-------------------------------------------------------------------------=
---

    S=E9 un Mejor Amante del Cine
    =BFQuieres saber c=F3mo? =A1Deja que otras personas te ayuden! .



-------------------------------------------------------------------------=
---


    =
-------------------------------------------------------------------------=

    This SF.net email is sponsored by: Splunk Inc.
    Still grepping through log files to find problems?  Stop.
    Now Search log events and configuration files using AJAX and a =
browser.
    Download your FREE copy of Splunk now >> http://get.splunk.com/=20


-------------------------------------------------------------------------=
---


    _______________________________________________
    Eqalign-devel mailing list
    Eqa...@li...
    https://lists.sourceforge.net/lists/listinfo/eqalign-devel



-------------------------------------------------------------------------=
-----


  =
-------------------------------------------------------------------------=

  This SF.net email is sponsored by: Splunk Inc.
  Still grepping through log files to find problems?  Stop.
  Now Search log events and configuration files using AJAX and a =
browser.
  Download your FREE copy of Splunk now >> http://get.splunk.com/


-------------------------------------------------------------------------=
-----


  _______________________________________________
  Eqalign-devel mailing list
  Eqa...@li...
  https://lists.sourceforge.net/lists/listinfo/eqalign-devel

Re: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase completada

[Antonio F. <ant...@ya...>]

Sem=E1foros... no soy un experto en paralelismo, pero creo que est=E1 =
funcionando de perlas. Tuve un problema al verlo con la webcam =
modificada: m=E1s que a menudo, cuando se invocaba el m=E9todo GetFrame =
la imagen no estaba disponible porque la variable booleana imgready =
estaba a false (la hab=EDa puesto a false el hilo de Exposure) aunque =
s=ED que hab=EDa una imagen disponible.
Creo que est=E1n bien implementados, los he incluido en QHY5Cam, Atik16 =
y WDMCam, no puedo probar la Atik16 porque no la tengo, as=ED que =
deber=EDas comprobarlo en la QHY5.
Todav=EDa falta recopilar la lista de c=E1maras activas y dem=E1s, me =
pongo a ello.
Francisco, tengo una duda con el m=E9todo Bitmap24FromUnmanagedCode:

for (int y =3D 0; y < bmp.Height; y++)
{
CopyMemory(dest, source, len);
source =3D new IntPtr(source.ToInt32() + len);
dest =3D new IntPtr(dest.ToInt32() + bmData.Stride);
}

la imagen de destino es de 3 bytes (1 byte por canal) y la imagen =
original de 1 byte, si copias CopyMemory(dest, source, len);, s=F3lo =
deber=EDas tener iformaci=F3n en el primer tercio de la imagen =BFno?, =
creo que el c=F3digo deber=EDa ser algo as=ED como:

byte* dst =3D (byte*)bmData.Scan0.ToPointer();
byte* src =3D (byte*)image.Scan0.ToPointer();
int offsetdst =3D dstData.Stride - width * 3;
int offsetsrc =3D image.Stride - width * 3;

for (int y =3D 0, idx =3D 0; y < height; y++)
{
    ushort* pDst =3D dst + y * width;
    ushort* pSrc =3D src + y * width;
    for (int x =3D 0; x < width; x++, pDst++)
    {
        // single input channel (greyscale)
        ushort v =3D *pSrc++;

        byte b =3D (byte)val;
        *pDst ++ =3D b;
        *pDst ++ =3D b;
        *pDst =3D b;
    }
    pDst +=3D offsetdst;
    pSrc +=3D offsetsrc;
}

pero deber=EDas comprobarlo.

Bueno, pues un saludo!
  ----- Original Message -----=20
  From: Antonio Fraga=20
  To: Lista de correo de desarrollo EQAlign=20
  Sent: Tuesday, October 09, 2007 3:09 PM
  Subject: Re: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase =
completada



  Buf!, un rollo patatoso! He modificado las especificaciones de =
CameraInterface:

  Propiedades p=FAblicas:
  string Driver  nombre del dispositivo
  bool IsConnected informa si la c=E1mara est=E1 conectada
  int Width  ancho de la imagen=20
  int Height  alto de la imagen
  Rectangle SubframeRegion region del subframe=20
  bool Subframe devuelve/establece el modo de subframa
  int ExposureTime tiempo de exposici=F3n (s=ED, como propiedad)
  eCameraReadOutMode ExposureMode modo de exposici=F3n (lo vemos)
  bool ImageReady informa si hay una imagen diponible
  DateTime CronoStart informa del momento en que se efectivamente se =
inici=F3 la exposici=F3n (para sincronizar la barra de presentaci=F3n de =
crono)

  M=E9todos p=FAblicos:
  void Connect() trata de establecer la conexi=F3n con la c=E1mara
  void Disconnect() desconecta la c=E1mara
  void Settings() lanza el di=E1logo de settings
  void Config()  lanza el di=E1logo de configuraci=F3n   (lo siento en =
WDM Config y Settings son dos cosas distintas)
  Bitmap GetFrame() devuelve el =FAltimo fotograma disponible.

  Adem=E1s hay que tener en cuenta que cuando se sirve al =FAltimo =
fotograma el buffer interno se vac=EDa: fotograma servido/fotograma =
perdido. Esto es as=ED para que el sistema de autoguiado (en caso de =
p=E9rdida de fotograma) no piense que no hay efectos sobre un comando =
gu=EDa.

  Sobre el modo de exposici=F3n. Un rollo, a ver si no me enrollo:
  Por una parte no interesa que el sistema est=E9 esperando en un bucle =
por una exposici=F3n, por eso antes el control de usuario era quien =
establec=EDa el inicio de exposici=F3n, controlaba el crono y luego =
cerraba la exposici=F3n; mientras ocurre todo esto, el sistema sigue =
activo.

  Pero tanto la Atik16, como la QHY (y probablemente todas las =
demaisss), el tiempo de exposici=F3n se establece en la llamada y luego =
hay que estar pendiente hasta que la imagen est=E1 disponible.

  Vale, soluci=F3n de en medio:
  Cuando la c=E1mara se conecta, se crea un hilo de exposici=F3n:
            //hilo de exposici=F3n
            ThExpose =3D new Thread(new ThreadStart(Exposure));
            ThExpose.TrySetApartmentState(ApartmentState.STA);
            ThExpose.Start();

  Este hilo est=E1 haciendo, en un loop "infinito" exposiciones =
continuas de tiempo (exposureTime), el hilo se queda esperando hasta que =
la imagen est=E1 disponible y entonces la carga en la propiedad privada =
Bitmap bmp.

  GetFrame, simplemente comprueba que la c=E1mara est=E1 conectada, que =
la propiedad bmp no es nula y que la imagen est=E1 disponible (por si =
acaso tambi=E9n que no estamos en un momento cr=EDtico: se est=E1 =
leyendo la imagen). En esos casos devuelve bmp.Clone() y libera bmp =
(fotograma servido, fotograma perdido).

  Para probar que todo esto funciona:
  -(y no perder el antiguo driver WDM) he reescrito otro driver WDMCam =
que se comporta de este modo. Simplemente tambi=E9n porque no tengo la =
Atik (est=E1 en el taller de reparacioones) as=ED que quer=EDa probar el =
tema de hilos con la webcam
  -he incorporado un driver m=EDnimo para la atik16
  -(para no perder QHY tal como estaba) he redise=F1ado QHYCam =
(copia/pega) para que cumpla el interfaz. Sobre QHY, cuidado, s=F3lo he =
a=F1adido las propiedades m=EDnimas del interfaz que debe cumplir para =
que compile.

  No lo he podido comprobar con la webcam modificada para LX, s=ED con =
una webcam CMOS barata.

  Vale uno de los problemas que me encontr=E9 era la sincronizaci=F3n =
entre el timmer de exposici=F3n del control de usuario y la =
disponibilidad efectiva de la imagen. Para minimizar las diferencias, =
a=F1ad=ED la propiedad CronoStart, que cada c=E1mara debe establecer =
como DateTime.Now justo antes de lanzar la larga exposici=F3n. A=FAn =
as=ED sigue habiendo alguna discrepancia que crea un efecto un poco =
raro, pero no se me ocurre otra cosa (excepto eliminar el progressBar)

  Esa es una. Otra es el modo de lectura:
    public enum eCameraReadOutMode
    {
      ContinueShortMode =3D 0,
      LXContinueMode,
      SingleShoot
    };

  Vamos, el modo ContinueShortMode en WDM es video en tiempo real, =
LXContinueMode es exposici=F3n LX cont=EDnua y SingleShoot, un solo =
"disparo" (no creo que tenga utilidad, excepto APRA las c=E1maras de =
luz)
  En WDM ok, pero para las QHY /Luna. Bien!! El tiempo de captura de una =
imagen no es muy largo, entonces podremos hacer algo as=ED como =
exposiciones de corto periodo para ir simulando un RealTimeVideo, ese =
ser=EDa el modo ContinueShortMode. No hay ninguna diferencia con =
respecto a LXContinueMode!!!! Es lo mismito. En este caso habr=E1 que =
establecer el tiempo de exposici=F3n a algo as=ED como 100ms y listo (lo =
hace el driver al establecer la propiedad ExposureMode).

  Tambi=E9n est=E1 el tema de Subframe y SubframeRegion. La Atik lo =
permite aunque todav=EDa no me funcionaba (cuando me venga de vuelta, lo =
retomar=E9).

  Me imagino que en las QHY s=F3lo hay que llamar a:
  uint ms =3D ProgramCamera(subframeregion.X, subframeregion.Y,=20
   ubframeregion.Width, subframeregion.Height,=20
   (int)convertGain(255));

  , as=ED lo puse en el m=E9todo set de la propiedad (despu=E9s de =
comprobar si la regi=F3n  es v=E1lida)

  En fin, como no tengo la Atik no puedo hacer pruebas. Si hay otras =
ideas pues a contar!!! Lo he implementado lo m=E1s r=E1pidamente posible =
para que no afecte al actual desarrollo de la beta y no he tocado WDM =
para poder tirar para atr=E1s.

  Otra cosa: ahora falta que Camera comience a hacer Connects a todo =
"quisque" para saber si est=E1 "presente" o no y poder construir la =
lista de c=E1maras disponibles. Luego MainWindow ya podr=EDa =
manej=E1rselas.. . si puedo lo hago esta noche.

  Y otra cosa, en la exposici=F3n (m=E9todo GetFrame) ten=EDais algo =
as=ED como:
  System.Drawing.Bitmap bmp =3D new System.Drawing.Bitmap(1280, 1024, =
format);
  System.Drawing.Imaging.BitmapData bmpData =3D bmp.LockBits(new =
System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), =
System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
  bmp.UnlockBits(bmpData);
  GETBUFFER(bmpData.Scan0, 1310720);

  // Obtenci=F3n del bitmap
  Bitmap bp =3D this.Bitmap24FromUnmanagedCode(bmpData.Scan0, 1280, =
1024);

  En QHYCam (recuerda que est=E1 en el m=E9todo Exposure que es un =
thread), lo he dejado as=ED:
  Bitmap bp =3D new System.Drawing.Bitmap(1280, 1024, format);
  BitmapData bmpData =3D bp.LockBits(new System.Drawing.Rectangle(0, 0, =
bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, =
format);
  GETBUFFER(bmpData.Scan0, 1310720);
  bmp =3D this.Bitmap24FromUnmanagedCode(bmpData.Scan0, 1280, 1024);
  bp.UnlockBits(bmpData);

  , la diferencia es que la l=EDnea bp.UnlockBits(bmpData), est=E1 =
despu=E9s de la llamada a Bitmap24FromUnmanagedCode. Mira si funciona, =
lo he hecho a ojo.

  Un saludo


  Francisco Jos=E9 <is...@ya...> escribi=F3:
    Hola Antonio!

    =BFSabes si han arreglado o tienen intenci=F3n de arreglar el tema =
de los 16 bits en .Net 3.0? En fin, sin comentarios... para trabajar con =
FITs, tambi=E9n tenemos FitsIO de la NASA =
(http://heasarc.gsfc.nasa.gov/docs/software/fitsio/) la usan muchos =
programas y est=E1 portada a varios sistemas operativos (Linux entre =
ellos), es software abierto aunque desconozco su licencia concreta.

    Sobre la QHY5 o Luna 1.3 o QGuider... pues va sobre USB 2.0, la =
descarga es muy r=E1pida y m=E1s a=FAn si trabajamos con subframes (es =
posible hacerlo), lo cual ser=EDa muy recomendable para el futuro.

    Hoy he subido un commit que resuelve un fallo en el control de =
ganancia de la c=E1mara, ha sido el propio Tom el que me lo ha =
corregido, la verdad, me alegro que haya cambiado tanto su =
comportamiento con nosotros, la c=E1mara est=E1 funcionando ahora =
perfectamente, me muero de ganas de verla en funcionamiento, tanto en la =
puesta en estaci=F3n como en el guiado, a ver si para este puente lo =
tenemos y me canso de hacer pruebas.

    Sobre las ideas que comentas, me parecen correctas, ten en cuenta =
que a la larga m=E1s y m=E1s c=E1maras ser=E1n a=F1adidas y la mayor=EDa =
tendr=E1n cron=F3metro interno, por mi parte, la siguiente en caer a no =
mucho tardar ser=E1 la Artemis, mas que para guiar (ser=EDa de g=E9nero =
absurdo usarla para eso), para poner en estaci=F3n, ser=E1 una gozada =
por el enorme campo que da.

    Ya me cuentas!

    Un saludo!


    ----- Mensaje original ----
    De: Antonio Fraga <ant...@ya...>
    Para: Lista de correo de desarrollo EQAlign =
<eqa...@li...>
    Enviado: lunes, 8 de octubre, 2007 18:34:58
    Asunto: Re: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase =
completada


    Hola Francisco!
    Pues mejor, 24bpp nos va a ahorrar algunos quebraderos de cabeza, =
sobre todo a la hora de dibujar el ret=EDculo.
    No s=F3lo Net2.0 sino el 1.0 (claro) tienen roto el modo 16bits. Por =
eso en su d=EDa evalu=E9 el proyecto FreeImage para trabajar a 16 bits. =
De todas maneras todav=EDa estamos en la fase de "C=E1mara gu=EDa", =
cuando lleguemos a "C=E1mara de luz" habr=E1 que plantearse guardar las =
im=E1genes en .FIT,  FreeImage no lo soporta, as=ED que tendremos que =
trabajar sobre el formato.

    Sobre la rapidez: =BFcu=E1nto tarda en descargarse una imagen =
completa?, me imagino que si no es USB2.0 tardar=E1 m=E1s de un par de =
segundos =BFno?
    En ese caso, como c=E1mara gu=EDa, lo ideal es se lo m=E1s r=E1pido =
posibles y eso se podr=EDa conseguir si el driver de la c=E1mara permite =
trabajar sobre "corps"

    Sobre el tiempo de exposici=F3n, lo mejor es aumentar el interfaz de =
c=E1mara y a=F1adir los m=E9todos LX. Tal como lo tenemos, el control de =
usuario de c=E1mara es el que cronometra el shutter, as=ED es como =
funcionan las webcam, pero el driver de las QHY, por lo que veo, tienen =
el crono interno y hay que especificarle en la llamada el tiempo de =
exposici=F3n.

    Podr=EDamos generalizarlo y ver c=F3mo encajan las webcamLX:

    para:
    StartLXMode
    StopLXMode
    las QHY no har=EDan nada, los implementan por compatibilidad

    el actual
    void startLXExposure(void)

    podr=EDa convertirse en=20
    void startLXExposure(int milliseconds)

    y en lugar de que el control de usuario de c=E1mara cronometre el =
tiempo de exposici=F3n, sea el propio startLXExposure quien lance un =
hilo.=20
    Actualmente el crono del control de usuario es el que termina la =
exposici=F3n cuando el tiempo se ha cumplido llamando a=20
    void stopLXExposure(void)

    este m=E9todo podr=EDa desaparecer y en su lugar, el hilo cuando =
termina la exposici=F3n se encargar=EDa de realizar el trabajo de =
stopLXExposure (en webcamLX) y lanzar un evento para informar que la =
imagen est=E1 disponible.

    S=F3lo hay que cambiar un par de cosas en:
    WDM.cs
    CameraInterface.cs
    UCCamControl.cs

    GetFrame() tal como est=E1 concebido s=F3lo se encargar=EDa de =
servir el =FAltimo fotograma almacenado, no de la exposici=F3n en s=ED, =
de eso se encargar=EDa:
    startLXExposure

    Excepto en modo video real, que s=ED se encarga de capturar la =
=FAltima imagen de la webcam.

    En las QHY, si el tiempo de descarga es peque=F1o (o si se puede =
trabajar con crops), entonces GetImage()  podr=EDa estar capturando en =
tiempos peque=F1os (0.1, 0.2, ... 0.5seg) configurables, tal como hace =
el actual WDM.

    Y sobre el men=FA de c=E1maras disponibles: Ok, Camera.cs debe =
capturar tanto la disponibilidad de c=E1maras WDM, como QHY y en el =
futuro DSI, Atik16IC, etc (jeje), para eso hay que modificar el m=E9todo =
GetDeviceList para que pregunte por la disponibilidad de cada c=E1mara =
que hayamos implementado. En la QHY b=E1sicamente habr=E1 que conectarla =
y desconectarla. Pero en lugar de mostrar mensajes, como haces ahora, =
deber=EDamos establecer un tipo enumerado con errores gen=E9ricos y =
devolver el error en una variable de status, de los mensajes ya ese =
encargar=E1n los "jefes" (por cierto habr=E1 que internacionalizar esos =
mensajes).

    >> Bueno, vaya mamotreto me ha quedado, lo dicho, gracias a los dos =
por la ayuda que me hab=E9is >> prestado, aunque mucho me temo que la =
volver=E9 a necesitar para mejorar el tema.

    =A1Venga ya! No me lo puedo creer :) p=E1-eso estamos aqu=ED =BFno?

    Bueno, d=E9jame un par de d=EDas para buscar c=F3mo las webcamLX =
(producto estrella hasta la llegada del driver QHY :) encajan con el =
nuevo modelo, esta noche lo tengo jo**do pero creo que ma=F1ana puedo =
dejarlo esbozado. Si hay alguna sugerencia o no est=E1n de acuerdo con =
el modelo ... a discutir!!!

    Un saludo
      ----- Original Message -----=20
      From: Francisco Jos=E9=20
      To: Lista correo EQAlign=20
      Sent: Monday, October 08, 2007 12:39 AM
      Subject: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase =
completada


      Pues el soporte preliminar de las QHY5 y derivadas ya est=E1 en el =
repositorio de EQAlign, como podr=E9is ver, al final y tras much=EDsimas =
pruebas me he decidido a trabajar directamente en 24bpp:
       - .NET 2.0 s=F3lo soporta 8 bits (que creo ser=EDa lo m=E1s =
eficiente) en modo indexado y en color, con lo que habr=EDa que =
transformar a escala de grises empleando recursos, lo que ganamos por un =
lado se pierde por otro.
      - .NET 2.0 tiene rotos todos los formatos de imagen de 16 bits, =
sabido es mi cari=F1o por los creadores del framework, de modo que evito =
comentarios que puedan resultar hirientes; en definitiva, descartado =
tambi=E9n.
      - Lo =FAnico que da buen resultado es trabajar directamente a =
24bpp, la c=E1mara puede retornar una imagen de este formato, y aunque =
pueda resultar un desperdicio de memoria he comprobado que es lo m=E1s =
r=E1pido al no tener que realizar transformaciones adicionales, esa es =
la soluci=F3n que he adoptado. No obstante ah=ED est=E1 el c=F3digo, lo =
pod=E9is modificar a vuestro antojo.

      Aunque el driver que implementa la interfaz CameraInterface est=E1 =
lista, quedan ciertos detalles para pulirla, a saber:
       - Necesito conocer el tiempo de exposici=F3n justo cuando se =
lanza =E9sta, con lo que de alguna manera habr=E1 que comunic=E1rselo al =
driver, tal y como est=E1 ahora dise=F1ado el sistema no lo veo trivial; =
podr=E9is ver que actualmente es el procedimiento GetFrame() el que =
realiza las tareas de:
             -  Lanzar la exposici=F3n (en un hilo)
             - Esperar a que termine la exposici=F3n..
             - Retornar la imagen (Bitmap)

      Sobre esto, una duda, cuando EQAlign lance la exposici=F3n =
=BFquedar=E1 bloqueado a la espera de que GetFrame() retorne la imagen?, =
Antonio, com=E9ntame si es as=ED. Como ves, el modo de funcionamiento de =
la c=E1mara es "iniciar exposici=F3n -> esperar -> obtener imagen", no =
tiene sentido un stopLx() o similar.=20

      Por compatibilidad con WDM he implementado las principales =
funciones LX de las webcams, pero como te digo, es que con el modo de =
funcionamiento de esta c=E1mara no les veo el sentido en este driver. La =
idea ser=EDa que lanzara una llamada no bloqueante a GetFrame cada x =
periodo de tiempo.

      Para concluir, falta la integraci=F3n final; no he querido tocar, =
por que es muy tarde y el sue=F1o puede hacer que destroce algo, pero en =
la interfaz principal hay que a=F1adir la nueva c=E1mara:
          - Que el men=FA C=E1mara se active si se detecta la QHY5
          - En caso de tener QHY y adem=E1s un WDM, permitir seleccionar =
uno de los dos.

      Para ello, creo que, al menos, habr=E1 que modificar el =
procedimiento GetDeviceList() de Camera.cs para a=F1adir soporte a m=E1s =
c=E1maras; y m=E1s cosillas, si no es mucha molestia, Antonio, dime =
exactamente lo que es necesario realizar.

      Bueno, vaya mamotreto me ha quedado, lo dicho, gracias a los dos =
por la ayuda que me hab=E9is prestado, aunque mucho me temo que la =
volver=E9 a necesitar para mejorar el tema.

      Un saludo.



-------------------------------------------------------------------------=
-

      S=E9 un Mejor Amante del Cine
      =BFQuieres saber c=F3mo? =A1Deja que otras personas te ayuden! .

      =
-------------------------------------------------------------------------=

      This SF.net email is sponsored by: Splunk Inc.
      Still grepping through log files to find problems?  Stop.
      Now Search log events and configuration files using AJAX and a =
browser.
      Download your FREE copy of Splunk now >> http://get.splunk.com/=20
      _______________________________________________
      Eqalign-devel mailing list
      Eqa...@li...
      https://lists.sourceforge.net/lists/listinfo/eqalign-devel





-------------------------------------------------------------------------=
---

    S=E9 un Mejor Amante del Cine
    =BFQuieres saber c=F3mo? =A1Deja que otras personas te ayuden! .
    =
-------------------------------------------------------------------------=

    This SF.net email is sponsored by: Splunk Inc.
    Still grepping through log files to find problems? Stop.
    Now Search log events and configuration files using AJAX and a =
browser.
    Download your FREE copy of Splunk now >> =
http://get.splunk.com/_______________________________________________
    Eqalign-devel mailing list
    Eqa...@li...
    https://lists.sourceforge.net/lists/listinfo/eqalign-devel





-------------------------------------------------------------------------=
-----

  S=E9 un Mejor Amante del Cine
  =BFQuieres saber c=F3mo? =A1Deja que otras personas te ayuden! .



-------------------------------------------------------------------------=
-----


  =
-------------------------------------------------------------------------=

  This SF.net email is sponsored by: Splunk Inc.
  Still grepping through log files to find problems?  Stop.
  Now Search log events and configuration files using AJAX and a =
browser.
  Download your FREE copy of Splunk now >> http://get.splunk.com/


-------------------------------------------------------------------------=
-----


  _______________________________________________
  Eqalign-devel mailing list
  Eqa...@li...
  https://lists.sourceforge.net/lists/listinfo/eqalign-devel

Re: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase completada

[Antonio F. <ant...@ya...>]

 
  Buf!, un rollo patatoso! He modificado las especificaciones de CameraInterface:
  
Propiedades públicas:
  string Driver  nombre del dispositivo
bool IsConnected informa si la cámara está conectada
int Width  ancho de la imagen 
int Height  alto de la imagen
Rectangle SubframeRegion region del subframe 
bool Subframe devuelve/establece el modo de subframa
int ExposureTime tiempo de exposición (sí, como propiedad)
eCameraReadOutMode ExposureMode modo de exposición (lo vemos)
bool ImageReady informa si hay una imagen diponible
DateTime CronoStart informa del momento en que se efectivamente se inició la exposición (para sincronizar la barra de presentación de crono)
  
Métodos públicos:
void Connect() trata de establecer la conexión con la cámara
void Disconnect() desconecta la cámara
void Settings() lanza el diálogo de settings
void Config()  lanza el diálogo de configuración   (lo siento en WDM Config y Settings son dos cosas distintas)
Bitmap GetFrame() devuelve el último fotograma disponible.
   
  Además hay que tener en cuenta que cuando se sirve al último fotograma el buffer interno se vacía: fotograma servido/fotograma perdido. Esto es así para que el sistema de autoguiado (en caso de pérdida de fotograma) no piense que no hay efectos sobre un comando guía.
   
  Sobre el modo de exposición. Un rollo, a ver si no me enrollo:
  Por una parte no interesa que el sistema esté esperando en un bucle por una exposición, por eso antes el control de usuario era quien establecía el inicio de exposición, controlaba el crono y luego cerraba la exposición; mientras ocurre todo esto, el sistema sigue activo.
   
  Pero tanto la Atik16, como la QHY (y probablemente todas las demaisss), el tiempo de exposición se establece en la llamada y luego hay que estar pendiente hasta que la imagen está disponible.
   
  Vale, solución de en medio:
  Cuando la cámara se conecta, se crea un hilo de exposición:
          //hilo de exposición
          ThExpose = new Thread(new ThreadStart(Exposure));
          ThExpose.TrySetApartmentState(ApartmentState.STA);
            ThExpose.Start();
   
  Este hilo está haciendo, en un loop “infinito” exposiciones continuas de tiempo (exposureTime), el hilo se queda esperando hasta que la imagen está disponible y entonces la carga en la propiedad privada Bitmap bmp.
   
  GetFrame, simplemente comprueba que la cámara está conectada, que la propiedad bmp no es nula y que la imagen está disponible (por si acaso también que no estamos en un momento crítico: se está leyendo la imagen). En esos casos devuelve bmp.Clone() y libera bmp (fotograma servido, fotograma perdido).
   
  Para probar que todo esto funciona:
-(y no perder el antiguo driver WDM) he reescrito otro driver WDMCam que se comporta de este modo. Simplemente también porque no tengo la Atik (está en el taller de reparacioones) así que quería probar el tema de hilos con la webcam
  -he incorporado un driver mínimo para la atik16
  -(para no perder QHY tal como estaba) he rediseñado QHYCam (copia/pega) para que cumpla el interfaz. Sobre QHY, cuidado, sólo he añadido las propiedades mínimas del interfaz que debe cumplir para que compile.
   
  No lo he podido comprobar con la webcam modificada para LX, sí con una webcam CMOS barata.
   
  Vale uno de los problemas que me encontré era la sincronización entre el timmer de exposición del control de usuario y la disponibilidad efectiva de la imagen. Para minimizar las diferencias, añadí la propiedad CronoStart, que cada cámara debe establecer como DateTime.Now justo antes de lanzar la larga exposición. Aún así sigue habiendo alguna discrepancia que crea un efecto un poco raro, pero no se me ocurre otra cosa (excepto eliminar el progressBar)
   
  Esa es una. Otra es el modo de lectura:
  public enum eCameraReadOutMode
  {
    ContinueShortMode = 0,
    LXContinueMode,
    SingleShoot
  };
   
  Vamos, el modo ContinueShortMode en WDM es video en tiempo real, LXContinueMode es exposición LX contínua y SingleShoot, un solo “disparo” (no creo que tenga utilidad, excepto APRA las cámaras de luz)
  En WDM ok, pero para las QHY /Luna. Bien!! El tiempo de captura de una imagen no es muy largo, entonces podremos hacer algo así como exposiciones de corto periodo para ir simulando un RealTimeVideo, ese sería el modo ContinueShortMode. No hay ninguna diferencia con respecto a LXContinueMode!!!! Es lo mismito. En este caso habrá que establecer el tiempo de exposición a algo así como 100ms y listo (lo hace el driver al establecer la propiedad ExposureMode).
   
  También está el tema de Subframe y SubframeRegion. La Atik lo permite aunque todavía no me funcionaba (cuando me venga de vuelta, lo retomaré).
   
  Me imagino que en las QHY sólo hay que llamar a:
uint ms = ProgramCamera(subframeregion.X, subframeregion.Y, 
 ubframeregion.Width, subframeregion.Height, 
 (int)convertGain(255));
   
  , así lo puse en el método set de la propiedad (después de comprobar si la región  es válida)
   
  En fin, como no tengo la Atik no puedo hacer pruebas. Si hay otras ideas pues a contar!!! Lo he implementado lo más rápidamente posible para que no afecte al actual desarrollo de la beta y no he tocado WDM para poder tirar para atrás.
   
  Otra cosa: ahora falta que Camera comience a hacer Connects a todo “quisque” para saber si está “presente” o no y poder construir la lista de cámaras disponibles. Luego MainWindow ya podría manejárselas.. . si puedo lo hago esta noche.
  
Y otra cosa, en la exposición (método GetFrame) teníais algo así como:
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
bmp.UnlockBits(bmpData);
GETBUFFER(bmpData.Scan0, 1310720);
  
// Obtención del bitmap
Bitmap bp = this.Bitmap24FromUnmanagedCode(bmpData.Scan0, 1280, 1024);
  
En QHYCam (recuerda que está en el método Exposure que es un thread), lo he dejado así:
Bitmap bp = new System.Drawing.Bitmap(1280, 1024, format);
BitmapData bmpData = bp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
GETBUFFER(bmpData.Scan0, 1310720);
bmp = this.Bitmap24FromUnmanagedCode(bmpData.Scan0, 1280, 1024);
bp.UnlockBits(bmpData);
  
, la diferencia es que la línea bp.UnlockBits(bmpData), está después de la llamada a Bitmap24FromUnmanagedCode. Mira si funciona, lo he hecho a ojo.
   
  Un saludo


Francisco José <is...@ya...> escribió:
          Hola Antonio!

¿Sabes si han arreglado o tienen intención de arreglar el tema de los 16 bits en .Net 3.0? En fin, sin comentarios... para trabajar con FITs, también tenemos FitsIO de la NASA (http://heasarc.gsfc.nasa.gov/docs/software/fitsio/) la usan muchos programas y está portada a varios sistemas operativos (Linux entre ellos), es software abierto aunque desconozco su licencia concreta.

Sobre la QHY5 o Luna 1.3 o QGuider... pues va sobre USB 2.0, la descarga es muy rápida y más aún si trabajamos con subframes (es posible hacerlo), lo cual sería muy recomendable para el futuro.

Hoy he subido un commit que resuelve un fallo en el control de ganancia de la cámara, ha sido el propio Tom el que me lo ha corregido, la verdad, me alegro que haya cambiado tanto su comportamiento con nosotros, la cámara está funcionando ahora perfectamente, me muero de ganas de verla en funcionamiento, tanto en la puesta en estación como en el guiado, a ver si para este puente lo tenemos y me canso de hacer pruebas.

Sobre las ideas que comentas, me parecen correctas, ten en cuenta que a la larga más y más cámaras serán añadidas y la mayoría tendrán cronómetro interno, por mi parte, la siguiente en caer a no mucho tardar será la Artemis, mas que para guiar (sería de género absurdo usarla para eso), para poner en estación, será una gozada por el enorme campo que da.

Ya me cuentas!

Un saludo!

  ----- Mensaje original ----
De: Antonio Fraga <ant...@ya...>
Para: Lista de correo de desarrollo EQAlign <eqa...@li...>
Enviado: lunes, 8 de octubre, 2007 18:34:58
Asunto: Re: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase completada

  DIV {  MARGIN:0px;}      Hola Francisco!
Pues mejor, 24bpp nos va a ahorrar algunos quebraderos de cabeza, sobre todo a la hora de dibujar el retículo.
No sólo Net2.0 sino el 1.0 (claro) tienen roto el modo 16bits. Por eso en su día evalué el proyecto FreeImage para trabajar a 16 bits. De todas maneras todavía estamos en la fase de “Cámara guía”, cuando lleguemos a “Cámara de luz” habrá que plantearse guardar las imágenes en .FIT,  FreeImage no lo soporta, así que tendremos que trabajar sobre el formato.
   
  Sobre la rapidez: ¿cuánto tarda en descargarse una imagen completa?, me imagino que si no es USB2.0 tardará más de un par de segundos ¿no?
En ese caso, como cámara guía, lo ideal es se lo más rápido posibles y eso se podría conseguir si el driver de la cámara permite trabajar sobre “corps”
   
  Sobre el tiempo de exposición, lo mejor es aumentar el interfaz de cámara y añadir los métodos LX. Tal como lo tenemos, el control de usuario de cámara es el que cronometra el shutter, así es como funcionan las webcam, pero el driver de las QHY, por lo que veo, tienen el crono interno y hay que especificarle en la llamada el tiempo de exposición.
   
  Podríamos generalizarlo y ver cómo encajan las webcamLX:
   
  para:
StartLXMode
StopLXMode
las QHY no harían nada, los implementan por compatibilidad
   
  el actual
void startLXExposure(void)
   
  podría convertirse en 
void startLXExposure(int milliseconds)
   
  y en lugar de que el control de usuario de cámara cronometre el tiempo de exposición, sea el propio startLXExposure quien lance un hilo. 
Actualmente el crono del control de usuario es el que termina la exposición cuando el tiempo se ha cumplido llamando a 
void stopLXExposure(void)
   
  este método podría desaparecer y en su lugar, el hilo cuando termina la exposición se encargaría de realizar el trabajo de stopLXExposure (en webcamLX) y lanzar un evento para informar que la imagen está disponible.
   
  Sólo hay que cambiar un par de cosas en:
WDM.cs
CameraInterface.cs
UCCamControl.cs
   
  GetFrame() tal como está concebido sólo se encargaría de servir el último fotograma almacenado, no de la exposición en sí, de eso se encargaría:
startLXExposure
   
  Excepto en modo video real, que sí se encarga de capturar la última imagen de la webcam.
   
  En las QHY, si el tiempo de descarga es pequeño (o si se puede trabajar con crops), entonces GetImage()  podría estar capturando en tiempos pequeños (0.1, 0.2, ... 0.5seg) configurables, tal como hace el actual WDM.
   
  Y sobre el menú de cámaras disponibles: Ok, Camera.cs debe capturar tanto la disponibilidad de cámaras WDM, como QHY y en el futuro DSI, Atik16IC, etc (jeje), para eso hay que modificar el método GetDeviceList para que pregunte por la disponibilidad de cada cámara que hayamos implementado. En la QHY básicamente habrá que conectarla y desconectarla. Pero en lugar de mostrar mensajes, como haces ahora, deberíamos establecer un tipo enumerado con errores genéricos y devolver el error en una variable de status, de los mensajes ya ese encargarán los “jefes” (por cierto habrá que internacionalizar esos mensajes).
   
  >> Bueno, vaya mamotreto me ha quedado, lo dicho, gracias a los dos por la ayuda que me habéis >> prestado, aunque mucho me temo que la volveré a necesitar para mejorar el tema.
   
  ¡Venga ya! No me lo puedo creer :) pá-eso estamos aquí ¿no?
   
  Bueno, déjame un par de días para buscar cómo las webcamLX (producto estrella hasta la llegada del driver QHY :) encajan con el nuevo modelo, esta noche lo tengo jo**do pero creo que mañana puedo dejarlo esbozado. Si hay alguna sugerencia o no están de acuerdo con el modelo ... a discutir!!!
   
  Un saludo
    ----- Original Message ----- 
  From: Francisco José 
  To: Lista correo EQAlign 
  Sent: Monday, October 08, 2007 12:39 AM
  Subject: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase completada
  

    Pues el soporte preliminar de las QHY5 y derivadas ya está en el repositorio de EQAlign, como podréis ver, al final y tras muchísimas pruebas me he decidido a trabajar directamente en 24bpp:
 - .NET 2.0 sólo soporta 8 bits (que creo sería lo más eficiente) en modo indexado y en color, con lo que habría que transformar a escala de grises empleando recursos, lo que ganamos por un lado se pierde por otro.
- .NET 2.0 tiene rotos todos los formatos de imagen de 16 bits, sabido es mi cariño por los creadores del framework, de modo que evito comentarios que puedan resultar hirientes; en definitiva, descartado también.
- Lo único que da buen resultado es trabajar directamente a 24bpp, la cámara puede retornar una imagen de este formato, y aunque pueda resultar un desperdicio de memoria he comprobado que es lo más rápido al no tener que realizar transformaciones adicionales, esa es la solución que he adoptado. No obstante ahí está el código, lo podéis modificar a vuestro antojo.

Aunque el driver que implementa la interfaz CameraInterface está lista, quedan ciertos detalles para pulirla, a saber:
 - Necesito conocer el tiempo de exposición justo cuando se lanza ésta, con lo que de alguna manera habrá que comunicárselo al driver, tal y como está ahora diseñado el sistema no lo veo trivial; podréis ver que actualmente es el procedimiento GetFrame() el que realiza las tareas de:
       -  Lanzar la exposición (en un hilo)
       - Esperar a que termine la exposición..
       - Retornar la imagen (Bitmap)

Sobre esto, una duda, cuando EQAlign lance la exposición ¿quedará bloqueado a la espera de que GetFrame() retorne la imagen?, Antonio, coméntame si es así. Como ves, el modo de funcionamiento de la cámara es "iniciar exposición -> esperar -> obtener imagen", no tiene sentido un stopLx() o similar. 

Por compatibilidad con WDM he implementado las principales funciones LX de las webcams, pero como te digo, es que con el modo de funcionamiento de esta cámara no les veo el sentido en este driver. La idea sería que lanzara una llamada no bloqueante a GetFrame cada x periodo de tiempo.

Para concluir, falta la integración final; no he querido tocar, por que es muy tarde y el sueño puede hacer que destroce algo, pero en la interfaz principal hay que añadir la nueva cámara:
    - Que el menú Cámara se active si se detecta la QHY5
    - En caso de tener QHY y además un WDM, permitir seleccionar uno de los dos.

Para ello, creo que, al menos, habrá que modificar el procedimiento GetDeviceList() de Camera.cs para añadir soporte a más cámaras; y más cosillas, si no es mucha molestia, Antonio, dime exactamente lo que es necesario realizar.

Bueno, vaya mamotreto me ha quedado, lo dicho, gracias a los dos por la ayuda que me habéis prestado, aunque mucho me temo que la volveré a necesitar para mejorar el tema.

Un saludo.



  
---------------------------------
  
Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden! .
  
  
-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems?  Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/   
  
_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel





  
---------------------------------
  
Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden! .
-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


       
---------------------------------

Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden!.

Re: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase completada

[<is...@ya...>]

Hola Antonio!=0A=0A=BFSabes si han arreglado o tienen intenci=F3n de arregl=
ar el tema de los 16 bits en .Net 3.0? En fin, sin comentarios... para trab=
ajar con FITs, tambi=E9n tenemos FitsIO de la NASA (http://heasarc.gsfc.nas=
a.gov/docs/software/fitsio/) la usan muchos programas y est=E1 portada a va=
rios sistemas operativos (Linux entre ellos), es software abierto aunque de=
sconozco su licencia concreta.=0A=0ASobre la QHY5 o Luna 1.3 o QGuider... p=
ues va sobre USB 2.0, la descarga es muy r=E1pida y m=E1s a=FAn si trabajam=
os con subframes (es posible hacerlo), lo cual ser=EDa muy recomendable par=
a el futuro.=0A=0AHoy he subido un commit que resuelve un fallo en el contr=
ol de ganancia de la c=E1mara, ha sido el propio Tom el que me lo ha correg=
ido, la verdad, me alegro que haya cambiado tanto su comportamiento con nos=
otros, la c=E1mara est=E1 funcionando ahora perfectamente, me muero de gana=
s de verla en funcionamiento, tanto en la puesta en estaci=F3n como en el g=
uiado, a ver si para este puente lo tenemos y me canso de hacer pruebas.=0A=
=0ASobre las ideas que comentas, me parecen correctas, ten en cuenta que a =
la larga m=E1s y m=E1s c=E1maras ser=E1n a=F1adidas y la mayor=EDa tendr=E1=
n cron=F3metro interno, por mi parte, la siguiente en caer a no mucho tarda=
r ser=E1 la Artemis, mas que para guiar (ser=EDa de g=E9nero absurdo usarla=
 para eso), para poner en estaci=F3n, ser=E1 una gozada por el enorme campo=
 que da.=0A=0AYa me cuentas!=0A=0AUn saludo!=0A=0A----- Mensaje original --=
--=0ADe: Antonio Fraga <ant...@ya...>=0APara: Lista de correo de des=
arrollo EQAlign <eqa...@li...>=0AEnviado: lunes, 8 d=
e octubre, 2007 18:34:58=0AAsunto: Re: [Eqalign-devel] Soporte QHY5 en EQAl=
ign. Primera fase completada=0A=0A=0A=0A =0ADIV {=0AMARGIN:0px;}=0A=0A=0A=
=0AHola Francisco!=0APues mejor, 24bpp nos va a =0Aahorrar algunos quebrade=
ros de cabeza, sobre todo a la hora de dibujar el =0Aret=EDculo.=0ANo s=F3l=
o Net2.0 sino el 1.0 (claro) tienen roto el modo 16bits. Por =0Aeso en su d=
=EDa evalu=E9 el proyecto FreeImage para trabajar a 16 bits. De todas =0Ama=
neras todav=EDa estamos en la fase de =93C=E1mara gu=EDa=94, cuando lleguem=
os a =93C=E1mara =0Ade luz=94 habr=E1 que plantearse guardar las im=E1genes=
 en .FIT,  FreeImage no lo =0Asoporta, as=ED que tendremos que trabajar sob=
re el formato.=0A=0A =0A=0ASobre la rapidez: =BFcu=E1nto tarda en descargar=
se una =0Aimagen completa?, me imagino que si no es USB2.0 tardar=E1 m=E1s =
de un par de =0Asegundos =BFno?=0AEn ese caso, como c=E1mara gu=EDa, lo ide=
al es se lo m=E1s r=E1pido =0Aposibles y eso se podr=EDa conseguir si el dr=
iver de la c=E1mara permite trabajar =0Asobre =93corps=94=0A=0A =0A=0ASobre=
 el tiempo de exposici=F3n, lo mejor es aumentar =0Ael interfaz de c=E1mara=
 y a=F1adir los m=E9todos LX. Tal como lo tenemos, el control =0Ade usuario=
 de c=E1mara es el que cronometra el shutter, as=ED es como funcionan las =
=0Awebcam, pero el driver de las QHY, por lo que veo, tienen el crono inter=
no y hay =0Aque especificarle en la llamada el tiempo de exposici=F3n.=0A=
=0A =0A=0APodr=EDamos generalizarlo y ver c=F3mo encajan las =0AwebcamLX:=
=0A=0A =0A=0Apara:=0AStartLXMode=0AStopLXMode=0Alas QHY no =0Ahar=EDan nada=
, los implementan por compatibilidad=0A=0A =0A=0Ael actual=0Avoid =0AstartL=
XExposure(void)=0A=0A =0A=0Apodr=EDa convertirse en =0Avoid startLXExposure=
(int =0Amilliseconds)=0A=0A =0A=0Ay en lugar de que el control de usuario d=
e c=E1mara =0Acronometre el tiempo de exposici=F3n, sea el propio startLXEx=
posure quien lance un =0Ahilo. =0AActualmente el crono del control de usuar=
io es el que termina la =0Aexposici=F3n cuando el tiempo se ha cumplido lla=
mando a =0Avoid =0AstopLXExposure(void)=0A=0A =0A=0Aeste m=E9todo podr=EDa =
desaparecer y en su lugar, el =0Ahilo cuando termina la exposici=F3n se enc=
argar=EDa de realizar el trabajo de =0AstopLXExposure (en webcamLX) y lanza=
r un evento para informar que la imagen est=E1 =0Adisponible.=0A=0A =0A=0AS=
=F3lo hay que cambiar un par de cosas =0Aen:=0AWDM.cs=0ACameraInterface.cs=
=0AUCCamControl.cs=0A=0A =0A=0AGetFrame() tal como est=E1 concebido s=F3lo =
se =0Aencargar=EDa de servir el =FAltimo fotograma almacenado, no de la exp=
osici=F3n en s=ED, =0Ade eso se encargar=EDa:=0AstartLXExposure=0A=0A =0A=
=0AExcepto en modo video real, que s=ED se encarga de =0Acapturar la =FAlti=
ma imagen de la webcam.=0A=0A =0A=0AEn las QHY, si el tiempo de descarga es=
 peque=F1o (o =0Asi se puede trabajar con crops), entonces GetImage()  podr=
=EDa estar =0Acapturando en tiempos peque=F1os (0.1, 0.2, ... 0.5seg) confi=
gurables, tal como =0Ahace el actual WDM.=0A=0A =0A=0AY sobre el men=FA de =
c=E1maras disponibles: Ok, =0ACamera.cs debe capturar tanto la disponibilid=
ad de c=E1maras WDM, como QHY y en el =0Afuturo DSI, Atik16IC, etc (jeje), =
para eso hay que modificar el m=E9todo =0AGetDeviceList para que pregunte p=
or la disponibilidad de cada c=E1mara que hayamos =0Aimplementado. En la QH=
Y b=E1sicamente habr=E1 que conectarla y desconectarla. Pero =0Aen lugar de=
 mostrar mensajes, como haces ahora, deber=EDamos establecer un tipo =0Aenu=
merado con errores gen=E9ricos y devolver el error en una variable de statu=
s, =0Ade los mensajes ya ese encargar=E1n los =93jefes=94 (por cierto habr=
=E1 que =0Ainternacionalizar esos mensajes).=0A=0A =0A=0A>> Bueno, vaya mam=
otreto me ha quedado, lo =0Adicho, gracias a los dos por la ayuda que me ha=
b=E9is >> prestado, aunque =0Amucho me temo que la volver=E9 a necesitar pa=
ra mejorar el tema.=0A=0A =0A=0A=A1Venga ya! No me lo puedo creer :) p=E1-e=
so estamos =0Aaqu=ED =BFno?=0A=0A =0A=0ABueno, d=E9jame un par de d=EDas pa=
ra buscar c=F3mo las =0AwebcamLX (producto estrella hasta la llegada del dr=
iver QHY :) encajan con el =0Anuevo modelo, esta noche lo tengo jo**do pero=
 creo que ma=F1ana puedo dejarlo =0Aesbozado. Si hay alguna sugerencia o no=
 est=E1n de acuerdo con el modelo ... a =0Adiscutir!!!=0A=0A =0A=0AUn salud=
o=0A=0A=0A  ----- Original Message ----- =0A=0A  From: =0A  Francisco Jos=
=E9 =0A  =0A=0A  To: Lista correo EQAlign =0A  =0A=0A  Sent: Monday, Octobe=
r 08, 2007 12:39 =0A  AM=0A=0A  Subject: [Eqalign-devel] Soporte QHY5 en =
=0A  EQAlign. Primera fase completada=0A=0A  =0A=0A=0A  =0A  Pues el soport=
e preliminar de las QHY5 y derivadas ya est=E1 en el =0A  repositorio de EQ=
Align, como podr=E9is ver, al final y tras much=EDsimas pruebas =0A  me he =
decidido a trabajar directamente en 24bpp:=0A - .NET 2.0 s=F3lo =0A  soport=
a 8 bits (que creo ser=EDa lo m=E1s eficiente) en modo indexado y en color,=
 =0A  con lo que habr=EDa que transformar a escala de grises empleando recu=
rsos, lo =0A  que ganamos por un lado se pierde por otro.=0A- .NET 2.0 tien=
e rotos todos =0A  los formatos de imagen de 16 bits, sabido es mi cari=F1o=
 por los creadores del =0A  framework, de modo que evito comentarios que pu=
edan resultar hirientes; en =0A  definitiva, descartado tambi=E9n.=0A- Lo =
=FAnico que da buen resultado es =0A  trabajar directamente a 24bpp, la c=
=E1mara puede retornar una imagen de este =0A  formato, y aunque pueda resu=
ltar un desperdicio de memoria he comprobado que =0A  es lo m=E1s r=E1pido =
al no tener que realizar transformaciones adicionales, esa es =0A  la soluc=
i=F3n que he adoptado. No obstante ah=ED est=E1 el c=F3digo, lo pod=E9is =
=0A  modificar a vuestro antojo.=0A=0AAunque el driver que implementa la in=
terfaz =0A  CameraInterface est=E1 lista, quedan ciertos detalles para puli=
rla, a =0A  saber:=0A - Necesito conocer el tiempo de exposici=F3n justo cu=
ando se =0A  lanza =E9sta, con lo que de alguna manera habr=E1 que comunic=
=E1rselo al driver, tal =0A  y como est=E1 ahora dise=F1ado el sistema no l=
o veo trivial; podr=E9is ver que =0A  actualmente es el procedimiento GetFr=
ame() el que realiza las tareas =0A  de:=0A       -  Lanzar la exposici=F3n=
 (en un =0A  hilo)=0A       - Esperar a que termine la =0A  exposici=F3n..=
=0A       - Retornar la imagen =0A  (Bitmap)=0A=0ASobre esto, una duda, cua=
ndo EQAlign lance la exposici=F3n =0A  =BFquedar=E1 bloqueado a la espera d=
e que GetFrame() retorne la imagen?, Antonio, =0A  com=E9ntame si es as=ED.=
 Como ves, el modo de funcionamiento de la c=E1mara es =0A  "iniciar exposi=
ci=F3n -> esperar -> obtener imagen", no tiene sentido un =0A  stopLx() o s=
imilar. =0A=0APor compatibilidad con WDM he implementado las =0A  principal=
es funciones LX de las webcams, pero como te digo, es que con el modo =0A  =
de funcionamiento de esta c=E1mara no les veo el sentido en este driver. La=
 idea =0A  ser=EDa que lanzara una llamada no bloqueante a GetFrame cada x =
periodo de =0A  tiempo.=0A=0APara concluir, falta la integraci=F3n final; n=
o he querido tocar, =0A  por que es muy tarde y el sue=F1o puede hacer que =
destroce algo, pero en la =0A  interfaz principal hay que a=F1adir la nueva=
 c=E1mara:=0A    - Que =0A  el men=FA C=E1mara se active si se detecta la Q=
HY5=0A    - En caso =0A  de tener QHY y adem=E1s un WDM, permitir seleccion=
ar uno de los dos.=0A=0APara =0A  ello, creo que, al menos, habr=E1 que mod=
ificar el procedimiento GetDeviceList() =0A  de Camera.cs para a=F1adir sop=
orte a m=E1s c=E1maras; y m=E1s cosillas, si no es mucha =0A  molestia, Ant=
onio, dime exactamente lo que es necesario =0A  realizar.=0A=0ABueno, vaya =
mamotreto me ha quedado, lo dicho, gracias a los =0A  dos por la ayuda que =
me hab=E9is prestado, aunque mucho me temo que la volver=E9 a =0A  necesita=
r para mejorar el tema.=0A=0AUn saludo.=0A=0A=0A=0A=0A  =0A  =0AS=E9 un Mej=
or Amante del Cine=0A=BFQuieres saber =0A  c=F3mo? =A1Deja =0A  que otras p=
ersonas te ayuden! .=0A=0A  =0A  =0A=0A=0A  =0A----------------------------=
---------------------------------------------=0AThis =0A  SF.net email is s=
ponsored by: Splunk Inc.=0AStill grepping through log files =0A  to find pr=
oblems?  Stop.=0ANow Search log events and configuration files =0A  using A=
JAX and a browser.=0ADownload your FREE copy of Splunk now >> =0A  http://g=
et.splunk.com/=0A  =0A  =0A=0A=0A  =0A_____________________________________=
__________=0AEqalign-devel =0A  mailing =0A  list=0AE...@li...u=
rceforge.net=0Ahttps://lists.sourceforge.net/lists/listinfo/eqalign-devel=
=0A=0A=0A=0A=0A=0A=0A       =0A____________________________________________=
________________________________________=0AS=E9 un Mejor Amante del Cine   =
                      =0A=BFQuieres saber c=F3mo? =A1Deja que otras persona=
s te ayuden!=0Ahttp://advision.webevents.yahoo.com/reto/entretenimiento.htm=
l

Re: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase completada

[Antonio F. <ant...@ya...>]

Hola Francisco!
Pues mejor, 24bpp nos va a ahorrar algunos quebraderos de cabeza, sobre =
todo a la hora de dibujar el ret=EDculo.
No s=F3lo Net2.0 sino el 1.0 (claro) tienen roto el modo 16bits. Por eso =
en su d=EDa evalu=E9 el proyecto FreeImage para trabajar a 16 bits. De =
todas maneras todav=EDa estamos en la fase de "C=E1mara gu=EDa", cuando =
lleguemos a "C=E1mara de luz" habr=E1 que plantearse guardar las =
im=E1genes en .FIT,  FreeImage no lo soporta, as=ED que tendremos que =
trabajar sobre el formato.

Sobre la rapidez: =BFcu=E1nto tarda en descargarse una imagen completa?, =
me imagino que si no es USB2.0 tardar=E1 m=E1s de un par de segundos =
=BFno?
En ese caso, como c=E1mara gu=EDa, lo ideal es se lo m=E1s r=E1pido =
posibles y eso se podr=EDa conseguir si el driver de la c=E1mara permite =
trabajar sobre "corps"

Sobre el tiempo de exposici=F3n, lo mejor es aumentar el interfaz de =
c=E1mara y a=F1adir los m=E9todos LX. Tal como lo tenemos, el control de =
usuario de c=E1mara es el que cronometra el shutter, as=ED es como =
funcionan las webcam, pero el driver de las QHY, por lo que veo, tienen =
el crono interno y hay que especificarle en la llamada el tiempo de =
exposici=F3n.

Podr=EDamos generalizarlo y ver c=F3mo encajan las webcamLX:

para:
StartLXMode
StopLXMode
las QHY no har=EDan nada, los implementan por compatibilidad

el actual
void startLXExposure(void)

podr=EDa convertirse en=20
void startLXExposure(int milliseconds)

y en lugar de que el control de usuario de c=E1mara cronometre el tiempo =
de exposici=F3n, sea el propio startLXExposure quien lance un hilo.=20
Actualmente el crono del control de usuario es el que termina la =
exposici=F3n cuando el tiempo se ha cumplido llamando a=20
void stopLXExposure(void)

este m=E9todo podr=EDa desaparecer y en su lugar, el hilo cuando termina =
la exposici=F3n se encargar=EDa de realizar el trabajo de stopLXExposure =
(en webcamLX) y lanzar un evento para informar que la imagen est=E1 =
disponible.

S=F3lo hay que cambiar un par de cosas en:
WDM.cs
CameraInterface.cs
UCCamControl.cs

GetFrame() tal como est=E1 concebido s=F3lo se encargar=EDa de servir el =
=FAltimo fotograma almacenado, no de la exposici=F3n en s=ED, de eso se =
encargar=EDa:
startLXExposure

Excepto en modo video real, que s=ED se encarga de capturar la =FAltima =
imagen de la webcam.

En las QHY, si el tiempo de descarga es peque=F1o (o si se puede =
trabajar con crops), entonces GetImage()  podr=EDa estar capturando en =
tiempos peque=F1os (0.1, 0.2, ... 0.5seg) configurables, tal como hace =
el actual WDM.

Y sobre el men=FA de c=E1maras disponibles: Ok, Camera.cs debe capturar =
tanto la disponibilidad de c=E1maras WDM, como QHY y en el futuro DSI, =
Atik16IC, etc (jeje), para eso hay que modificar el m=E9todo =
GetDeviceList para que pregunte por la disponibilidad de cada c=E1mara =
que hayamos implementado. En la QHY b=E1sicamente habr=E1 que conectarla =
y desconectarla. Pero en lugar de mostrar mensajes, como haces ahora, =
deber=EDamos establecer un tipo enumerado con errores gen=E9ricos y =
devolver el error en una variable de status, de los mensajes ya ese =
encargar=E1n los "jefes" (por cierto habr=E1 que internacionalizar esos =
mensajes).

>> Bueno, vaya mamotreto me ha quedado, lo dicho, gracias a los dos por =
la ayuda que me hab=E9is >> prestado, aunque mucho me temo que la =
volver=E9 a necesitar para mejorar el tema.

=A1Venga ya! No me lo puedo creer :) p=E1-eso estamos aqu=ED =BFno?

Bueno, d=E9jame un par de d=EDas para buscar c=F3mo las webcamLX =
(producto estrella hasta la llegada del driver QHY :) encajan con el =
nuevo modelo, esta noche lo tengo jo**do pero creo que ma=F1ana puedo =
dejarlo esbozado. Si hay alguna sugerencia o no est=E1n de acuerdo con =
el modelo ... a discutir!!!

Un saludo
  ----- Original Message -----=20
  From: Francisco Jos=E9=20
  To: Lista correo EQAlign=20
  Sent: Monday, October 08, 2007 12:39 AM
  Subject: [Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase =
completada


  Pues el soporte preliminar de las QHY5 y derivadas ya est=E1 en el =
repositorio de EQAlign, como podr=E9is ver, al final y tras much=EDsimas =
pruebas me he decidido a trabajar directamente en 24bpp:
   - .NET 2.0 s=F3lo soporta 8 bits (que creo ser=EDa lo m=E1s =
eficiente) en modo indexado y en color, con lo que habr=EDa que =
transformar a escala de grises empleando recursos, lo que ganamos por un =
lado se pierde por otro.
  - .NET 2.0 tiene rotos todos los formatos de imagen de 16 bits, sabido =
es mi cari=F1o por los creadores del framework, de modo que evito =
comentarios que puedan resultar hirientes; en definitiva, descartado =
tambi=E9n.
  - Lo =FAnico que da buen resultado es trabajar directamente a 24bpp, =
la c=E1mara puede retornar una imagen de este formato, y aunque pueda =
resultar un desperdicio de memoria he comprobado que es lo m=E1s =
r=E1pido al no tener que realizar transformaciones adicionales, esa es =
la soluci=F3n que he adoptado. No obstante ah=ED est=E1 el c=F3digo, lo =
pod=E9is modificar a vuestro antojo.

  Aunque el driver que implementa la interfaz CameraInterface est=E1 =
lista, quedan ciertos detalles para pulirla, a saber:
   - Necesito conocer el tiempo de exposici=F3n justo cuando se lanza =
=E9sta, con lo que de alguna manera habr=E1 que comunic=E1rselo al =
driver, tal y como est=E1 ahora dise=F1ado el sistema no lo veo trivial; =
podr=E9is ver que actualmente es el procedimiento GetFrame() el que =
realiza las tareas de:
         -  Lanzar la exposici=F3n (en un hilo)
         - Esperar a que termine la exposici=F3n..
         - Retornar la imagen (Bitmap)

  Sobre esto, una duda, cuando EQAlign lance la exposici=F3n =
=BFquedar=E1 bloqueado a la espera de que GetFrame() retorne la imagen?, =
Antonio, com=E9ntame si es as=ED. Como ves, el modo de funcionamiento de =
la c=E1mara es "iniciar exposici=F3n -> esperar -> obtener imagen", no =
tiene sentido un stopLx() o similar.=20

  Por compatibilidad con WDM he implementado las principales funciones =
LX de las webcams, pero como te digo, es que con el modo de =
funcionamiento de esta c=E1mara no les veo el sentido en este driver. La =
idea ser=EDa que lanzara una llamada no bloqueante a GetFrame cada x =
periodo de tiempo.

  Para concluir, falta la integraci=F3n final; no he querido tocar, por =
que es muy tarde y el sue=F1o puede hacer que destroce algo, pero en la =
interfaz principal hay que a=F1adir la nueva c=E1mara:
      - Que el men=FA C=E1mara se active si se detecta la QHY5
      - En caso de tener QHY y adem=E1s un WDM, permitir seleccionar uno =
de los dos.

  Para ello, creo que, al menos, habr=E1 que modificar el procedimiento =
GetDeviceList() de Camera.cs para a=F1adir soporte a m=E1s c=E1maras; y =
m=E1s cosillas, si no es mucha molestia, Antonio, dime exactamente lo =
que es necesario realizar.

  Bueno, vaya mamotreto me ha quedado, lo dicho, gracias a los dos por =
la ayuda que me hab=E9is prestado, aunque mucho me temo que la volver=E9 =
a necesitar para mejorar el tema.

  Un saludo.



-------------------------------------------------------------------------=
-----

  S=E9 un Mejor Amante del Cine
  =BFQuieres saber c=F3mo? =A1Deja que otras personas te ayuden! .



-------------------------------------------------------------------------=
-----


  =
-------------------------------------------------------------------------=

  This SF.net email is sponsored by: Splunk Inc.
  Still grepping through log files to find problems?  Stop.
  Now Search log events and configuration files using AJAX and a =
browser.
  Download your FREE copy of Splunk now >> http://get.splunk.com/


-------------------------------------------------------------------------=
-----


  _______________________________________________
  Eqalign-devel mailing list
  Eqa...@li...
  https://lists.sourceforge.net/lists/listinfo/eqalign-devel

[Eqalign-devel] Beta 1

[<is...@ya...>]

Se me olvidaba, he modificado algunas cosillas:=0A     - Al cuadro de di=E1=
logo "Acerca de..." hace referencia al a=F1o 2007, y he a=F1adido a Tom por=
 el tema de la DLL (puro formalismo).=0A    - Algunos retoques est=E9ticos,=
 como la inclusi=F3n del logotipo de Alphacigny (a debatir).=0A     - He mo=
dificado el instalador, de modo que ahora incluye la CMOSDLL (beta del 25 d=
e Septiembre), sobre ese api estamos trabajando.=0A    - Ajuste de la image=
n de cabecera del intalador, que se estiraba y quedaba fatal.=0A=0AUn salud=
o.=0A=0A=0A=0A=0A       =0A________________________________________________=
____________________________________=0AS=E9 un Mejor Amante del Cine       =
                  =0A=BFQuieres saber c=F3mo? =A1Deja que otras personas te=
 ayuden!=0Ahttp://advision.webevents.yahoo.com/reto/entretenimiento.html

[Eqalign-devel] Soporte QHY5 en EQAlign. Primera fase completada

[<is...@ya...>]

Pues el soporte preliminar de las QHY5 y derivadas ya est=E1 en el reposito=
rio de EQAlign, como podr=E9is ver, al final y tras much=EDsimas pruebas me=
 he decidido a trabajar directamente en 24bpp:=0A - .NET 2.0 s=F3lo soporta=
 8 bits (que creo ser=EDa lo m=E1s eficiente) en modo indexado y en color, =
con lo que habr=EDa que transformar a escala de grises empleando recursos, =
lo que ganamos por un lado se pierde por otro.=0A- .NET 2.0 tiene rotos tod=
os los formatos de imagen de 16 bits, sabido es mi cari=F1o por los creador=
es del framework, de modo que evito comentarios que puedan resultar hirient=
es; en definitiva, descartado tambi=E9n.=0A- Lo =FAnico que da buen resulta=
do es trabajar directamente a 24bpp, la c=E1mara puede retornar una imagen =
de este formato, y aunque pueda resultar un desperdicio de memoria he compr=
obado que es lo m=E1s r=E1pido al no tener que realizar transformaciones ad=
icionales, esa es la soluci=F3n que he adoptado. No obstante ah=ED est=E1 e=
l c=F3digo, lo pod=E9is modificar a vuestro antojo.=0A=0AAunque el driver q=
ue implementa la interfaz CameraInterface est=E1 lista, quedan ciertos deta=
lles para pulirla, a saber:=0A - Necesito conocer el tiempo de exposici=F3n=
 justo cuando se lanza =E9sta, con lo que de alguna manera habr=E1 que comu=
nic=E1rselo al driver, tal y como est=E1 ahora dise=F1ado el sistema no lo =
veo trivial; podr=E9is ver que actualmente es el procedimiento GetFrame() e=
l que realiza las tareas de:=0A         -  Lanzar la exposici=F3n (en un hi=
lo)=0A        - Esperar a que termine la exposici=F3n.=0A        - Retornar=
 la imagen (Bitmap)=0A=0ASobre esto, una duda, cuando EQAlign lance la expo=
sici=F3n =BFquedar=E1 bloqueado a la espera de que GetFrame() retorne la im=
agen?, Antonio, com=E9ntame si es as=ED. Como ves, el modo de funcionamient=
o de la c=E1mara es "iniciar exposici=F3n -> esperar -> obtener imagen", no=
 tiene sentido un stopLx() o similar. =0A=0APor compatibilidad con WDM he i=
mplementado las principales funciones LX de las webcams, pero como te digo,=
 es que con el modo de funcionamiento de esta c=E1mara no les veo el sentid=
o en este driver. La idea ser=EDa que lanzara una llamada no bloqueante a G=
etFrame cada x periodo de tiempo.=0A=0APara concluir, falta la integraci=F3=
n final; no he querido tocar, por que es muy tarde y el sue=F1o puede hacer=
 que destroce algo, pero en la interfaz principal hay que a=F1adir la nueva=
 c=E1mara:=0A    - Que el men=FA C=E1mara se active si se detecta la QHY5=
=0A    - En caso de tener QHY y adem=E1s un WDM, permitir seleccionar uno d=
e los dos.=0A=0APara ello, creo que, al menos, habr=E1 que modificar el pro=
cedimiento GetDeviceList() de Camera.cs para a=F1adir soporte a m=E1s c=E1m=
aras; y m=E1s cosillas, si no es mucha molestia, Antonio, dime exactamente =
lo que es necesario realizar.=0A=0ABueno, vaya mamotreto me ha quedado, lo =
dicho, gracias a los dos por la ayuda que me hab=E9is prestado, aunque much=
o me temo que la volver=E9 a necesitar para mejorar el tema.=0A=0AUn saludo=
..=0A=0A=0A=0A=0A       =0A_________________________________________________=
___________________________________=0AS=E9 un Mejor Amante del Cine        =
                 =0A=BFQuieres saber c=F3mo? =A1Deja que otras personas te =
ayuden!=0Ahttp://advision.webevents.yahoo.com/reto/entretenimiento.html

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[Antonio F. <ant...@ya...>]

Tenías razón del todo Andrés:
   
  Bitmap bp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
  , también falla si el formato de bp es Format16bppGrayScale o Format8bppIndexed, lo acabo de comprobar.
   
  Otra manera hubiera sido:
   
  Bitmap bp = bmp.Clone(new Rectangle(0,0, bmp.Width, bmp.Height), PixelFormat.Format24bppRgb);
   
  , pero falla lo mismo si bmp es Format16bppGrayScale o Format8bppIndexed.
   
  EQAlign tabaja con funciones de Graphics, así que necesitamos que las imágenes sean Format24bppRgb. El único algoritmo que queda es el de Andrés.
   
    Otra cosa, el acceso a 16bits será lento para ese tamaño de imagen, habría que estudiar cómo trabajar en modo subframe en esa cámara Francisco, como en al Atik.

  
Antonio Fraga <ant...@ya...> escribió:
    Bitmap bp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
  no funciona: 
"A Graphics object cannot be created from an image that has an indexed pixel format."
   
  De todas maneras este formato nos va a dar problemas en las funciones de astrometría y cálculso de centroides. 
   
  
Antonio Fraga <ant...@ya...> escribió:
    Si vas a tener razón. De todas formas, si son 2 bytes por pixel y un sólo canal de color:
   
  IntPtr hBitmap = Marshal.AllocHGlobal(16 * width * height);
GETBUFFER(hBitmap, width * height);
   
  ¿no tendría que ser?:
   
  IntPtr hBitmap = Marshal.AllocHGlobal(2 * width * height);
GETBUFFER(hBitmap, 2 * width * height);
   
  De cualquier manera, ¿funciona o no funciona pasarla el puntero de la imagen bloqueada?:
   
  Bitmap bmp = new System.Drawing.Bitmap(width, height, PixelFormat.Format16bppGrayScale);
  BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, bmp.PixelFormat);
  GETBUFFER(bmpData.Scan0, 2 * width * height);
  bmp.UnlockBits(bmpData);
   
  Si eso funciona, y el bmp queda ya creado, no veo por qué deba fallar pasar a cualquier otro formato con Graphics.DrawImage:
  
 
  Bitmap bp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
   
  o 
   
   
  Bitmap bp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
   
  , habría que probarlo.
   
  Saludos
  
Andres del Pozo Prieto <and...@gm...> escribió:
  Con la solución que has puesto le va a dar un error de memoria. Si crea un bitmap de 8bpp, solo reserva memoria para 1 byte por pixel. Sin embargo la función GETBUFFER intenta escribir 2bytes por pixel.

Personalmente creo que la mejor solución que tiene Francisco es hacer lo siguiente:

* Crear un buffer de 16bpp para almacenar la memoria original tal como hacía al principio
* Crear un Bitmap de 8bpp y obtener su BitmapData
* Volcar a mano los datos de la imagen sobre el bitmap de 8bpp utilizando un trozo de código unsafe.

La ventaja de este mecanismo es que en la traducción de 16bpp a 8bpp se puede aplicar cualquier fórmula de escalado para cambiar brillo, contraste o utilizar una curva de luminosidad no lineal:

IntPtr hBitmap = Marshal.AllocHGlobal(16 * width * height);
GETBUFFER(hBitmap, width* height);

PixelFormat format =  PixelFormat.Format8bppGrayScale; 
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(width, height, format); 

System.Drawing.Imaging.BitmapData bmpData = 
         bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), 
                      System.Drawing.Imaging.ImageLockMode.ReadWrite, 
                      format);

unsafe
{
   for (int y = 0; y < bmpData.Height; ++y)
   {
      short* buff_in = (short*)hBitmap + bmpData.Width * y;
      byte* buff_out = (byte*)bmpData.Scan0 + y * bmpData.Stride;
      for(int x=0; x<bmpData.Width; x++)
      {
         buff_out[x]=Transform(buff_in[x]);
      }
       }
}

El problema es que esto es relativamente lento. Si la DLL en C++ está hecha por Francisco se podría implementar un GETBUFFER16 y un GETBUFFER8 que devuelvan los datos en el formato que se necesita.

Saludos,

Andrés.

Antonio Fraga wrote:     Prueba esto a ver si es más lento:
   
  ....
  PixelFormat format = PixelFormat.Format8bppIndexed;
  System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
  System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
  GETBUFFER(bmpData.Scan0, 1310720);
  bmp.UnlockBits(bmpData);
   
   
  Bitmap bp = new Bitmap(bmp.Width, bmp.Height, PixelFormat.Format24bppRgb);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
  .....
   
  

Francisco José <is...@ya...> escribió:
  Parece ser que el formato de 16 bits en escala de grises está roto en el GDI+, cojonudo. La buena noticia es que a 8 bits indexados parece que el tema funciona... pero a color!! siendo la cámara monocromo, en fin, he realizado una burda transformación con la paleta de colores, ya que las funciones setpixel/getpixel no se llevan bien con los 8 bits indexados; a más bits, realmente sólo leía una parte del buffer... muy raro; os paso el extracto del código que funciona, mañana lo intento subir al SVN y mejorar:

Inicialización:

// Buffer de 8bits RAW
            SETBUFFERMODE(1);

Función de captura:

void CapturarClick(object sender, EventArgs e)
        {
                ThreadedExposure((uint)int.Parse(tExposicion.Text), null);
                while(isExposing()!=0)
                {
                    this.mensaje.Text = "Exponiendo...";
                    Console.Write("Exponiendo\n");
                }
                
                // Ahora leemos los datos del buffer
                this.mensaje.Text = "Leyendo datos...";
                
                // El buffer será de 2621440 bytes (16 bits por pixel, 
                // la cámara tiene 1310720 pixels)
                
                PixelFormat format =  PixelFormat.Format8bppIndexed;
                System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
                System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
                GETBUFFER(bmpData.Scan0,1310720);
                bmp.UnlockBits(bmpData);
                            
                
                // Obtención del bitmap
                Bitmap bp = Bitmap8FromUnmanagedArray1(bmpData.Scan0,1280,1024);
                
                // Transformación a escala de grises.
                ColorPalette greyPal = bp.Palette;

                for(int i = 0;i<256;i++)
                {
                    greyPal.Entries[i] = Color.FromArgb(255,i,i,i);
                }
                bp.Palette = greyPal;
                imagenFrame.Image = bp;
                bp.Save(@"c:\test.jpg", ImageFormat.Jpeg);
        }

Creación del bitmap:

 private Bitmap Bitmap8FromUnmanagedArray1(IntPtr image, int width, int height)
        {
            Bitmap bmp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);

            BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);

            IntPtr dest = bmData.Scan0;
            IntPtr source = image;
            int len = width;

            if ( bmData.Stride == len )
            {
                CopyMemory(dest, source, width*height);
            }
            else
            {
                for( int y = 0; y < bmp.Height; y++ )
                {
                    CopyMemory(dest, source, len);

                    source = new IntPtr(source.ToInt32() + len);
                    dest = new IntPtr(dest.ToInt32() + bmData.Stride);
                }
            }
            
            bmp.UnlockBits(bmData);

            return bmp;
        }
    
---------------------------------
  
Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden! .
-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


  
  
---------------------------------
  
LLama Gratis a cualquier PC del Mundo.
Llamadas a fijos y móviles desde 1 céntimo por minuto.
http://es.voice.yahoo.com 

---------------------------------
  -------------------------------------------------------------------------  This SF.net email is sponsored by: Splunk Inc.  Still grepping through   log files to find problems?  Stop.  Now Search log events and configuration files using AJAX and a browser.  Download your FREE copy of Splunk now >> http://get.splunk.com/


---------------------------------
  _______________________________________________  Eqalign-devel mailing list  Eqa...@li...  https://lists.sourceforge.net/lists/listinfo/eqalign-devel    

-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel

    
---------------------------------
  
LLama Gratis a cualquier PC del Mundo.
Llamadas a fijos y móviles desde 1 céntimo por minuto.
http://es.voice.yahoo.com-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


    
---------------------------------
  
Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden! .
-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel



       
---------------------------------

Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden!.

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[Antonio F. <ant...@ya...>]

Tenías razón del todo Andrés:
   
  Bitmap bp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
  , también falla si el formato de bp es Format16bppGrayScale o Format8bppIndexed, lo acabo de comprobar.
   
  Otra manera hubiera sido:
   
  Bitmap bp = bmp.Clone(new Rectangle(0,0, bmp.Width, bmp.Height), PixelFormat.Format24bppRgb);
   
  , pero falla lo mismo si bmp es Format16bppGrayScale o Format8bppIndexed.
   
  EQAlign tabaja con funciones de Graphics, así que necesitamos que las imágenes sean Format24bppRgb. El único algoritmo que queda es el de Andrés.
  
Antonio Fraga <ant...@ya...> escribió:
    Bitmap bp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
  no funciona: 
"A Graphics object cannot be created from an image that has an indexed pixel format."
   
  De todas maneras este formato nos va a dar problemas en las funciones de astrometría y cálculso de centroides. 
   
  
Antonio Fraga <ant...@ya...> escribió:
    Si vas a tener razón. De todas formas, si son 2 bytes por pixel y un sólo canal de color:
   
  IntPtr hBitmap = Marshal.AllocHGlobal(16 * width * height);
GETBUFFER(hBitmap, width * height);
   
  ¿no tendría que ser?:
   
  IntPtr hBitmap = Marshal.AllocHGlobal(2 * width * height);
GETBUFFER(hBitmap, 2 * width * height);
   
  De cualquier manera, ¿funciona o no funciona pasarla el puntero de la imagen bloqueada?:
   
  Bitmap bmp = new System.Drawing.Bitmap(width, height, PixelFormat.Format16bppGrayScale);
  BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, bmp.PixelFormat);
  GETBUFFER(bmpData.Scan0, 2 * width * height);
  bmp.UnlockBits(bmpData);
   
  Si eso funciona, y el bmp queda ya creado, no veo por qué deba fallar pasar a cualquier otro formato con Graphics.DrawImage:
  
 
  Bitmap bp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
   
  o 
   
   
  Bitmap bp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
   
  , habría que probarlo.
   
  Saludos
  
Andres del Pozo Prieto <and...@gm...> escribió:
  Con la solución que has puesto le va a dar un error de memoria. Si crea un bitmap de 8bpp, solo reserva memoria para 1 byte por pixel. Sin embargo la función GETBUFFER intenta escribir 2bytes por pixel.

Personalmente creo que la mejor solución que tiene Francisco es hacer lo siguiente:

* Crear un buffer de 16bpp para almacenar la memoria original tal como hacía al principio
* Crear un Bitmap de 8bpp y obtener su BitmapData
* Volcar a mano los datos de la imagen sobre el bitmap de 8bpp utilizando un trozo de código unsafe.

La ventaja de este mecanismo es que en la traducción de 16bpp a 8bpp se puede aplicar cualquier fórmula de escalado para cambiar brillo, contraste o utilizar una curva de luminosidad no lineal:

IntPtr hBitmap = Marshal.AllocHGlobal(16 * width * height);
GETBUFFER(hBitmap, width* height);

PixelFormat format =  PixelFormat.Format8bppGrayScale; 
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(width, height, format); 

System.Drawing.Imaging.BitmapData bmpData = 
         bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), 
                      System.Drawing.Imaging.ImageLockMode.ReadWrite, 
                      format);

unsafe
{
   for (int y = 0; y < bmpData.Height; ++y)
   {
      short* buff_in = (short*)hBitmap + bmpData.Width * y;
      byte* buff_out = (byte*)bmpData.Scan0 + y * bmpData.Stride;
      for(int x=0; x<bmpData.Width; x++)
      {
         buff_out[x]=Transform(buff_in[x]);
      }
       }
}

El problema es que esto es relativamente lento. Si la DLL en C++ está hecha por Francisco se podría implementar un GETBUFFER16 y un GETBUFFER8 que devuelvan los datos en el formato que se necesita.

Saludos,

Andrés.

Antonio Fraga wrote:     Prueba esto a ver si es más lento:
   
  ....
  PixelFormat format = PixelFormat.Format8bppIndexed;
  System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
  System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
  GETBUFFER(bmpData.Scan0, 1310720);
  bmp.UnlockBits(bmpData);
   
   
  Bitmap bp = new Bitmap(bmp.Width, bmp.Height, PixelFormat.Format24bppRgb);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
  .....
   
  

Francisco José <is...@ya...> escribió:
  Parece ser que el formato de 16 bits en escala de grises está roto en el GDI+, cojonudo. La buena noticia es que a 8 bits indexados parece que el tema funciona... pero a color!! siendo la cámara monocromo, en fin, he realizado una burda transformación con la paleta de colores, ya que las funciones setpixel/getpixel no se llevan bien con los 8 bits indexados; a más bits, realmente sólo leía una parte del buffer... muy raro; os paso el extracto del código que funciona, mañana lo intento subir al SVN y mejorar:

Inicialización:

// Buffer de 8bits RAW
            SETBUFFERMODE(1);

Función de captura:

void CapturarClick(object sender, EventArgs e)
        {
                ThreadedExposure((uint)int.Parse(tExposicion.Text), null);
                while(isExposing()!=0)
                {
                    this.mensaje.Text = "Exponiendo...";
                    Console.Write("Exponiendo\n");
                }
                
                // Ahora leemos los datos del buffer
                this.mensaje.Text = "Leyendo datos...";
                
                // El buffer será de 2621440 bytes (16 bits por pixel, 
                // la cámara tiene 1310720 pixels)
                
                PixelFormat format =  PixelFormat.Format8bppIndexed;
                System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
                System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
                GETBUFFER(bmpData.Scan0,1310720);
                bmp.UnlockBits(bmpData);
                            
                
                // Obtención del bitmap
                Bitmap bp = Bitmap8FromUnmanagedArray1(bmpData.Scan0,1280,1024);
                
                // Transformación a escala de grises.
                ColorPalette greyPal = bp.Palette;

                for(int i = 0;i<256;i++)
                {
                    greyPal.Entries[i] = Color.FromArgb(255,i,i,i);
                }
                bp.Palette = greyPal;
                imagenFrame.Image = bp;
                bp.Save(@"c:\test.jpg", ImageFormat.Jpeg);
        }

Creación del bitmap:

 private Bitmap Bitmap8FromUnmanagedArray1(IntPtr image, int width, int height)
        {
            Bitmap bmp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);

            BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);

            IntPtr dest = bmData.Scan0;
            IntPtr source = image;
            int len = width;

            if ( bmData.Stride == len )
            {
                CopyMemory(dest, source, width*height);
            }
            else
            {
                for( int y = 0; y < bmp.Height; y++ )
                {
                    CopyMemory(dest, source, len);

                    source = new IntPtr(source.ToInt32() + len);
                    dest = new IntPtr(dest.ToInt32() + bmData.Stride);
                }
            }
            
            bmp.UnlockBits(bmData);

            return bmp;
        }
    
---------------------------------
  
Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden! .
-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


  
  
---------------------------------
  
LLama Gratis a cualquier PC del Mundo.
Llamadas a fijos y móviles desde 1 céntimo por minuto.
http://es.voice.yahoo.com 

---------------------------------
  -------------------------------------------------------------------------  This SF.net email is sponsored by: Splunk Inc.  Still grepping through   log files to find problems?  Stop.  Now Search log events and configuration files using AJAX and a browser.  Download your FREE copy of Splunk now >> http://get.splunk.com/


---------------------------------
  _______________________________________________  Eqalign-devel mailing list  Eqa...@li...  https://lists.sourceforge.net/lists/listinfo/eqalign-devel    

-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel

    
---------------------------------
  
LLama Gratis a cualquier PC del Mundo.
Llamadas a fijos y móviles desde 1 céntimo por minuto.
http://es.voice.yahoo.com-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


    
---------------------------------
  
Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden! .
-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


 		
---------------------------------

LLama Gratis a cualquier PC del Mundo.
Llamadas a fijos y móviles desde 1 céntimo por minuto.
http://es.voice.yahoo.com

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[Antonio F. <ant...@ya...>]

Bitmap bp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
  no funciona: 
"A Graphics object cannot be created from an image that has an indexed pixel format."
   
  De todas maneras este formato nos va a dar problemas en las funciones de astrometría y cálculso de centroides. 
   
  
Antonio Fraga <ant...@ya...> escribió:
    Si vas a tener razón. De todas formas, si son 2 bytes por pixel y un sólo canal de color:
   
  IntPtr hBitmap = Marshal.AllocHGlobal(16 * width * height);
GETBUFFER(hBitmap, width * height);
   
  ¿no tendría que ser?:
   
  IntPtr hBitmap = Marshal.AllocHGlobal(2 * width * height);
GETBUFFER(hBitmap, 2 * width * height);
   
  De cualquier manera, ¿funciona o no funciona pasarla el puntero de la imagen bloqueada?:
   
  Bitmap bmp = new System.Drawing.Bitmap(width, height, PixelFormat.Format16bppGrayScale);
  BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, bmp.PixelFormat);
  GETBUFFER(bmpData.Scan0, 2 * width * height);
  bmp.UnlockBits(bmpData);
   
  Si eso funciona, y el bmp queda ya creado, no veo por qué deba fallar pasar a cualquier otro formato con Graphics.DrawImage:
  
 
  Bitmap bp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
   
  o 
   
   
  Bitmap bp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
   
  , habría que probarlo.
   
  Saludos
  
Andres del Pozo Prieto <and...@gm...> escribió:
  Con la solución que has puesto le va a dar un error de memoria. Si crea un bitmap de 8bpp, solo reserva memoria para 1 byte por pixel. Sin embargo la función GETBUFFER intenta escribir 2bytes por pixel.

Personalmente creo que la mejor solución que tiene Francisco es hacer lo siguiente:

* Crear un buffer de 16bpp para almacenar la memoria original tal como hacía al principio
* Crear un Bitmap de 8bpp y obtener su BitmapData
* Volcar a mano los datos de la imagen sobre el bitmap de 8bpp utilizando un trozo de código unsafe.

La ventaja de este mecanismo es que en la traducción de 16bpp a 8bpp se puede aplicar cualquier fórmula de escalado para cambiar brillo, contraste o utilizar una curva de luminosidad no lineal:

IntPtr hBitmap = Marshal.AllocHGlobal(16 * width * height);
GETBUFFER(hBitmap, width* height);

PixelFormat format =  PixelFormat.Format8bppGrayScale; 
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(width, height, format); 

System.Drawing.Imaging.BitmapData bmpData = 
         bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), 
                      System.Drawing.Imaging.ImageLockMode.ReadWrite, 
                      format);

unsafe
{
   for (int y = 0; y < bmpData.Height; ++y)
   {
      short* buff_in = (short*)hBitmap + bmpData.Width * y;
      byte* buff_out = (byte*)bmpData.Scan0 + y * bmpData.Stride;
      for(int x=0; x<bmpData.Width; x++)
      {
         buff_out[x]=Transform(buff_in[x]);
      }
       }
}

El problema es que esto es relativamente lento. Si la DLL en C++ está hecha por Francisco se podría implementar un GETBUFFER16 y un GETBUFFER8 que devuelvan los datos en el formato que se necesita.

Saludos,

Andrés.

Antonio Fraga wrote:     Prueba esto a ver si es más lento:
   
  ....
  PixelFormat format = PixelFormat.Format8bppIndexed;
  System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
  System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
  GETBUFFER(bmpData.Scan0, 1310720);
  bmp.UnlockBits(bmpData);
   
   
  Bitmap bp = new Bitmap(bmp.Width, bmp.Height, PixelFormat.Format24bppRgb);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
  .....
   
  

Francisco José <is...@ya...> escribió:
  Parece ser que el formato de 16 bits en escala de grises está roto en el GDI+, cojonudo. La buena noticia es que a 8 bits indexados parece que el tema funciona... pero a color!! siendo la cámara monocromo, en fin, he realizado una burda transformación con la paleta de colores, ya que las funciones setpixel/getpixel no se llevan bien con los 8 bits indexados; a más bits, realmente sólo leía una parte del buffer... muy raro; os paso el extracto del código que funciona, mañana lo intento subir al SVN y mejorar:

Inicialización:

// Buffer de 8bits RAW
            SETBUFFERMODE(1);

Función de captura:

void CapturarClick(object sender, EventArgs e)
        {
                ThreadedExposure((uint)int.Parse(tExposicion.Text), null);
                while(isExposing()!=0)
                {
                    this.mensaje.Text = "Exponiendo...";
                    Console.Write("Exponiendo\n");
                }
                
                // Ahora leemos los datos del buffer
                this.mensaje.Text = "Leyendo datos...";
                
                // El buffer será de 2621440 bytes (16 bits por pixel, 
                // la cámara tiene 1310720 pixels)
                
                PixelFormat format =  PixelFormat.Format8bppIndexed;
                System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
                System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
                GETBUFFER(bmpData.Scan0,1310720);
                bmp.UnlockBits(bmpData);
                            
                
                // Obtención del bitmap
                Bitmap bp = Bitmap8FromUnmanagedArray1(bmpData.Scan0,1280,1024);
                
                // Transformación a escala de grises.
                ColorPalette greyPal = bp.Palette;

                for(int i = 0;i<256;i++)
                {
                    greyPal.Entries[i] = Color.FromArgb(255,i,i,i);
                }
                bp.Palette = greyPal;
                imagenFrame.Image = bp;
                bp.Save(@"c:\test.jpg", ImageFormat.Jpeg);
        }

Creación del bitmap:

 private Bitmap Bitmap8FromUnmanagedArray1(IntPtr image, int width, int height)
        {
            Bitmap bmp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);

            BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);

            IntPtr dest = bmData.Scan0;
            IntPtr source = image;
            int len = width;

            if ( bmData.Stride == len )
            {
                CopyMemory(dest, source, width*height);
            }
            else
            {
                for( int y = 0; y < bmp.Height; y++ )
                {
                    CopyMemory(dest, source, len);

                    source = new IntPtr(source.ToInt32() + len);
                    dest = new IntPtr(dest.ToInt32() + bmData.Stride);
                }
            }
            
            bmp.UnlockBits(bmData);

            return bmp;
        }
    
---------------------------------
  
Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden! .
-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


  
  
---------------------------------
  
LLama Gratis a cualquier PC del Mundo.
Llamadas a fijos y móviles desde 1 céntimo por minuto.
http://es.voice.yahoo.com 

---------------------------------
  -------------------------------------------------------------------------  This SF.net email is sponsored by: Splunk Inc.  Still grepping through log files to find problems?  Stop.  Now Search log events and configuration files using AJAX and a browser.  Download your FREE copy of Splunk now >> http://get.splunk.com/


---------------------------------
  _______________________________________________  Eqalign-devel mailing list  Eqa...@li...  https://lists.sourceforge.net/lists/listinfo/eqalign-devel    

-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel

    
---------------------------------
  
LLama Gratis a cualquier PC del Mundo.
Llamadas a fijos y móviles desde 1 céntimo por minuto.
http://es.voice.yahoo.com-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


       
---------------------------------

Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden!.

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[Antonio F. <ant...@ya...>]

Si vas a tener razón. De todas formas, si son 2 bytes por pixel y un sólo canal de color:
   
  IntPtr hBitmap = Marshal.AllocHGlobal(16 * width * height);
GETBUFFER(hBitmap, width * height);
   
  ¿no tendría que ser?:
   
  IntPtr hBitmap = Marshal.AllocHGlobal(2 * width * height);
GETBUFFER(hBitmap, 2 * width * height);
   
  De cualquier manera, ¿funciona o no funciona pasarla el puntero de la imagen bloqueada?:
   
  Bitmap bmp = new System.Drawing.Bitmap(width, height, PixelFormat.Format16bppGrayScale);
  BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, bmp.PixelFormat);
  GETBUFFER(bmpData.Scan0, 2 * width * height);
  bmp.UnlockBits(bmpData);
   
  Si eso funciona, y el bmp queda ya creado, no veo por qué deba fallar pasar a cualquier otro formato con Graphics.DrawImage:
  
 
  Bitmap bp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
   
  o 
   
   
  Bitmap bp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
   
  , habría que probarlo.
   
  Saludos
  
Andres del Pozo Prieto <and...@gm...> escribió:
  Con la solución que has puesto le va a dar un error de memoria. Si crea un bitmap de 8bpp, solo reserva memoria para 1 byte por pixel. Sin embargo la función GETBUFFER intenta escribir 2bytes por pixel.

Personalmente creo que la mejor solución que tiene Francisco es hacer lo siguiente:

* Crear un buffer de 16bpp para almacenar la memoria original tal como hacía al principio
* Crear un Bitmap de 8bpp y obtener su BitmapData
* Volcar a mano los datos de la imagen sobre el bitmap de 8bpp utilizando un trozo de código unsafe.

La ventaja de este mecanismo es que en la traducción de 16bpp a 8bpp se puede aplicar cualquier fórmula de escalado para cambiar brillo, contraste o utilizar una curva de luminosidad no lineal:

IntPtr hBitmap = Marshal.AllocHGlobal(16 * width * height);
GETBUFFER(hBitmap, width* height);

PixelFormat format =  PixelFormat.Format8bppGrayScale; 
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(width, height, format); 

System.Drawing.Imaging.BitmapData bmpData = 
         bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), 
                      System.Drawing.Imaging.ImageLockMode.ReadWrite, 
                      format);

unsafe
{
   for (int y = 0; y < bmpData.Height; ++y)
   {
      short* buff_in = (short*)hBitmap + bmpData.Width * y;
      byte* buff_out = (byte*)bmpData.Scan0 + y * bmpData.Stride;
      for(int x=0; x<bmpData.Width; x++)
      {
         buff_out[x]=Transform(buff_in[x]);
      }
       }
}

El problema es que esto es relativamente lento. Si la DLL en C++ está hecha por Francisco se podría implementar un GETBUFFER16 y un GETBUFFER8 que devuelvan los datos en el formato que se necesita.

Saludos,

Andrés.

Antonio Fraga wrote:     Prueba esto a ver si es más lento:
   
  ....
  PixelFormat format = PixelFormat.Format8bppIndexed;
  System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
  System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
  GETBUFFER(bmpData.Scan0, 1310720);
  bmp.UnlockBits(bmpData);
   
   
  Bitmap bp = new Bitmap(bmp.Width, bmp.Height, PixelFormat.Format24bppRgb);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
  .....
   
  

Francisco José <is...@ya...> escribió:
  Parece ser que el formato de 16 bits en escala de grises está roto en el GDI+, cojonudo. La buena noticia es que a 8 bits indexados parece que el tema funciona... pero a color!! siendo la cámara monocromo, en fin, he realizado una burda transformación con la paleta de colores, ya que las funciones setpixel/getpixel no se llevan bien con los 8 bits indexados; a más bits, realmente sólo leía una parte del buffer... muy raro; os paso el extracto del código que funciona, mañana lo intento subir al SVN y mejorar:

Inicialización:

// Buffer de 8bits RAW
            SETBUFFERMODE(1);

Función de captura:

void CapturarClick(object sender, EventArgs e)
        {
                ThreadedExposure((uint)int.Parse(tExposicion.Text), null);
                while(isExposing()!=0)
                {
                    this.mensaje.Text = "Exponiendo...";
                    Console.Write("Exponiendo\n");
                }
                
                // Ahora leemos los datos del buffer
                this.mensaje.Text = "Leyendo datos...";
                
                // El buffer será de 2621440 bytes (16 bits por pixel, 
                // la cámara tiene 1310720 pixels)
                
                PixelFormat format =  PixelFormat.Format8bppIndexed;
                System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
                System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
                GETBUFFER(bmpData.Scan0,1310720);
                bmp.UnlockBits(bmpData);
                            
                
                // Obtención del bitmap
                Bitmap bp = Bitmap8FromUnmanagedArray1(bmpData.Scan0,1280,1024);
                
                // Transformación a escala de grises.
                ColorPalette greyPal = bp.Palette;

                for(int i = 0;i<256;i++)
                {
                    greyPal.Entries[i] = Color.FromArgb(255,i,i,i);
                }
                bp.Palette = greyPal;
                imagenFrame.Image = bp;
                bp.Save(@"c:\test.jpg", ImageFormat.Jpeg);
        }

Creación del bitmap:

 private Bitmap Bitmap8FromUnmanagedArray1(IntPtr image, int width, int height)
        {
            Bitmap bmp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);

            BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);

            IntPtr dest = bmData.Scan0;
            IntPtr source = image;
            int len = width;

            if ( bmData.Stride == len )
            {
                CopyMemory(dest, source, width*height);
            }
            else
            {
                for( int y = 0; y < bmp.Height; y++ )
                {
                    CopyMemory(dest, source, len);

                    source = new IntPtr(source.ToInt32() + len);
                    dest = new IntPtr(dest.ToInt32() + bmData.Stride);
                }
            }
            
            bmp.UnlockBits(bmData);

            return bmp;
        }
    
---------------------------------
  
Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden! .
-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


  
  
---------------------------------
  
LLama Gratis a cualquier PC del Mundo.
Llamadas a fijos y móviles desde 1 céntimo por minuto.
http://es.voice.yahoo.com 

---------------------------------
  -------------------------------------------------------------------------  This SF.net email is sponsored by: Splunk Inc.  Still grepping through log files to find problems?  Stop.  Now Search log events and configuration files using AJAX and a browser.  Download your FREE copy of Splunk now >> http://get.splunk.com/


---------------------------------
  _______________________________________________  Eqalign-devel mailing list  Eqa...@li...  https://lists.sourceforge.net/lists/listinfo/eqalign-devel    

-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


 		
---------------------------------

LLama Gratis a cualquier PC del Mundo.
Llamadas a fijos y móviles desde 1 céntimo por minuto.
http://es.voice.yahoo.com

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[Andres d. P. P. <and...@gm...>]

Con la solución que has puesto le va a dar un error de memoria. Si crea 
un bitmap de 8bpp, solo reserva memoria para 1 byte por pixel. Sin 
embargo la función GETBUFFER intenta escribir 2bytes por pixel.

Personalmente creo que la mejor solución que tiene Francisco es hacer lo 
siguiente:

* Crear un buffer de 16bpp para almacenar la memoria original tal como 
hacía al principio
* Crear un Bitmap de 8bpp y obtener su BitmapData
* Volcar a mano los datos de la imagen sobre el bitmap de 8bpp 
utilizando un trozo de código unsafe.

La ventaja de este mecanismo es que en la traducción de 16bpp a 8bpp se 
puede aplicar cualquier fórmula de escalado para cambiar brillo, 
contraste o utilizar una curva de luminosidad no lineal:

IntPtr hBitmap = Marshal.AllocHGlobal(16 * width * height);
GETBUFFER(hBitmap, width* height);

PixelFormat format =  PixelFormat.Format8bppGrayScale;
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(width, height, 
format);

System.Drawing.Imaging.BitmapData bmpData =
         bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, 
bmp.Height),
                      System.Drawing.Imaging.ImageLockMode.ReadWrite,
                      format);

unsafe
{
   for (int y = 0; y < bmpData.Height; ++y)
   {
      short* buff_in = (short*)hBitmap + bmpData.Width * y;
      byte* buff_out = (byte*)bmpData.Scan0 + y * bmpData.Stride;
      for(int x=0; x<bmpData.Width; x++)
      {
         buff_out[x]=Transform(buff_in[x]);
      }
       }
}

El problema es que esto es relativamente lento. Si la DLL en C++ está 
hecha por Francisco se podría implementar un GETBUFFER16 y un GETBUFFER8 
que devuelvan los datos en el formato que se necesita.

Saludos,

Andrés.

Antonio Fraga wrote:
> Prueba esto a ver si es más lento:
>  
> ....
> PixelFormat format = PixelFormat.Format8bppIndexed;
> System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
> System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new 
> System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), 
> System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
> GETBUFFER(bmpData.Scan0, 1310720);
> bmp.UnlockBits(bmpData);
>  
>  
> Bitmap bp = new Bitmap(bmp.Width, bmp.Height, PixelFormat.Format24bppRgb);
> Graphics g = Graphics.FromImage(bp);
> g.DrawImage(bmp, new Point(0, 0));
> g.Dispose();
> bmp.Dispose();
>  
> .....
>  
>
>
> */Francisco José <is...@ya...>/* escribió:
>
>     Parece ser que el formato de 16 bits en escala de grises está roto
>     en el GDI+, cojonudo. La buena noticia es que a 8 bits indexados
>     parece que el tema funciona... pero a color!! siendo la cámara
>     monocromo, en fin, he realizado una burda transformación con la
>     paleta de colores, ya que las funciones setpixel/getpixel no se
>     llevan bien con los 8 bits indexados; a más bits, realmente sólo
>     leía una parte del buffer... muy raro; os paso el extracto del
>     código que funciona, mañana lo intento subir al SVN y mejorar:
>
>     Inicialización:
>
>     // Buffer de 8bits RAW
>                 SETBUFFERMODE(1);
>
>     Función de captura:
>
>     void CapturarClick(object sender, EventArgs e)
>             {
>                    
>     ThreadedExposure((uint)int.Parse(tExposicion.Text), null);
>                     while(isExposing()!=0)
>                     {
>                         this.mensaje.Text = "Exponiendo...";
>                         Console.Write("Exponiendo\n");
>                     }
>                    
>                     // Ahora leemos los datos del buffer
>                     this.mensaje.Text = "Leyendo datos...";
>                    
>                     // El buffer será de 2621440 bytes (16 bits por
>     pixel,
>                     // la cámara tiene 1310720 pixels)
>                    
>                     PixelFormat format =  PixelFormat.Format8bppIndexed;
>                     System.Drawing.Bitmap bmp = new
>     System.Drawing.Bitmap(1280, 1024, format);
>                     System.Drawing.Imaging.BitmapData bmpData =
>     bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width,
>     bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
>                     GETBUFFER(bmpData.Scan0,1310720);
>                     bmp.UnlockBits(bmpData);
>                                
>                    
>                     // Obtención del bitmap
>                     Bitmap bp =
>     Bitmap8FromUnmanagedArray1(bmpData.Scan0,1280,1024);
>                    
>                     // Transformación a escala de grises.
>                     ColorPalette greyPal = bp.Palette;
>
>                     for(int i = 0;i<256;i++)
>                     {
>                         greyPal.Entries[i] = Color.FromArgb(255,i,i,i);
>                     }
>                     bp.Palette = greyPal;
>                     imagenFrame.Image = bp;
>                     bp.Save(@"c:\test.jpg", ImageFormat.Jpeg);
>             }
>
>     Creación del bitmap:
>
>      private Bitmap Bitmap8FromUnmanagedArray1(IntPtr image, int
>     width, int height)
>             {
>                 Bitmap bmp = new Bitmap(width, height,
>     PixelFormat.Format8bppIndexed);
>
>                 BitmapData bmData = bmp.LockBits(new Rectangle(0, 0,
>     bmp.Width, bmp.Height),
>                     ImageLockMode.ReadWrite,
>     PixelFormat.Format8bppIndexed);
>
>                 IntPtr dest = bmData.Scan0;
>                 IntPtr source = image;
>                 int len = width;
>
>                 if ( bmData.Stride == len )
>                 {
>                     CopyMemory(dest, source, width*height);
>                 }
>                 else
>                 {
>                     for( int y = 0; y < bmp.Height; y++ )
>                     {
>                         CopyMemory(dest, source, len);
>
>                         source = new IntPtr(source.ToInt32() + len);
>                         dest = new IntPtr(dest.ToInt32() + bmData.Stride);
>                     }
>                 }
>                
>                 bmp.UnlockBits(bmData);
>
>                 return bmp;
>             }
>     ------------------------------------------------------------------------
>
>     Sé un Mejor Amante del Cine
>     ¿Quieres saber cómo? ¡Deja que otras personas te ayuden!
>     <http://us.rd.yahoo.com/mail/es/tagline/beabetter/*http://advision.webevents.yahoo.com/reto/entretenimiento.html>.
>     -------------------------------------------------------------------------
>     This SF.net email is sponsored by: Splunk Inc.
>     Still grepping through log files to find problems? Stop.
>     Now Search log events and configuration files using AJAX and a
>     browser.
>     Download your FREE copy of Splunk now >>
>     http://get.splunk.com/_______________________________________________
>     Eqalign-devel mailing list
>     Eqa...@li...
>     https://lists.sourceforge.net/lists/listinfo/eqalign-devel
>
>
> ------------------------------------------------------------------------
>
> LLama Gratis a cualquier PC del Mundo.
> Llamadas a fijos y móviles desde 1 céntimo por minuto.
> http://es.voice.yahoo.com 
> <http://us.rd.yahoo.com/mail/es/tagline/messenger/*http://es.voice.yahoo.com/> 
>
> ------------------------------------------------------------------------
>
> -------------------------------------------------------------------------
> This SF.net email is sponsored by: Splunk Inc.
> Still grepping through log files to find problems?  Stop.
> Now Search log events and configuration files using AJAX and a browser.
> Download your FREE copy of Splunk now >> http://get.splunk.com/
> ------------------------------------------------------------------------
>
> _______________________________________________
> Eqalign-devel mailing list
> Eqa...@li...
> https://lists.sourceforge.net/lists/listinfo/eqalign-devel
>   

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[Antonio F. <ant...@ya...>]

Otra cosa, en el código que envías:
   
  .........
                  GETBUFFER(bmpData.Scan0,1310720);
                bmp.UnlockBits(bmpData);
                            
                
                // Obtención del bitmap
                Bitmap bp = Bitmap8FromUnmanagedArray1(bmpData.Scan0,1280,1024);
                
                // Transformación a escala de grises.
                ColorPalette greyPal = bp.Palette;
  .........
   
  desbloqueas el acceso a memora antes de llamar a Bitmap8FromUnmanagedArray1, cuando dentro de la función usas el modo protegido para acceder al contenido. 
   
  En la pripia función utilizas
      int len = width;

  y funciona porque la profundidad de color es 1 y porque da la casualidad que Stride = width, pero casi es mejor que le envíes el BitmapData en lugar del puntero y utilices bmpData.Stride.
   
  De todas maneras prueba el código que te envié y comprueba si es más lento o más rápido.
   
  Ya nos cuentas!
  
Francisco José <is...@ya...> escribió:
  Parece ser que el formato de 16 bits en escala de grises está roto en el GDI+, cojonudo. La buena noticia es que a 8 bits indexados parece que el tema funciona... pero a color!! siendo la cámara monocromo, en fin, he realizado una burda transformación con la paleta de colores, ya que las funciones setpixel/getpixel no se llevan bien con los 8 bits indexados; a más bits, realmente sólo leía una parte del buffer... muy raro; os paso el extracto del código que funciona, mañana lo intento subir al SVN y mejorar:

Inicialización:

// Buffer de 8bits RAW
            SETBUFFERMODE(1);

Función de captura:

void CapturarClick(object sender, EventArgs e)
        {
                ThreadedExposure((uint)int.Parse(tExposicion.Text), null);
                while(isExposing()!=0)
                {
                    this.mensaje.Text = "Exponiendo...";
                    Console.Write("Exponiendo\n");
                }
                
                // Ahora leemos los datos del buffer
                this.mensaje.Text = "Leyendo datos...";
                
                // El buffer será de 2621440 bytes (16 bits por pixel, 
                // la cámara tiene 1310720 pixels)
                
                PixelFormat format =  PixelFormat.Format8bppIndexed;
                System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
                System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
                GETBUFFER(bmpData.Scan0,1310720);
                bmp.UnlockBits(bmpData);
                            
                
                // Obtención del bitmap
                Bitmap bp = Bitmap8FromUnmanagedArray1(bmpData.Scan0,1280,1024);
                
                // Transformación a escala de grises.
                ColorPalette greyPal = bp.Palette;

                for(int i = 0;i<256;i++)
                {
                    greyPal.Entries[i] = Color.FromArgb(255,i,i,i);
                }
                bp.Palette = greyPal;
                imagenFrame.Image = bp;
                bp.Save(@"c:\test.jpg", ImageFormat.Jpeg);
        }

Creación del bitmap:

 private Bitmap Bitmap8FromUnmanagedArray1(IntPtr image, int width, int height)
        {
            Bitmap bmp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);

            BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);

            IntPtr dest = bmData.Scan0;
            IntPtr source = image;
            int len = width;

            if ( bmData.Stride == len )
            {
                CopyMemory(dest, source, width*height);
            }
            else
            {
                for( int y = 0; y < bmp.Height; y++ )
                {
                    CopyMemory(dest, source, len);

                    source = new IntPtr(source.ToInt32() + len);
                    dest = new IntPtr(dest.ToInt32() + bmData.Stride);
                }
            }
            
            bmp.UnlockBits(bmData);

            return bmp;
        }
    
---------------------------------
  
Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden! .
-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


       
---------------------------------

Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden!.

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[Antonio F. <ant...@ya...>]

Prueba esto a ver si es más lento:
   
  ....
  PixelFormat format = PixelFormat.Format8bppIndexed;
  System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
  System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
  GETBUFFER(bmpData.Scan0, 1310720);
  bmp.UnlockBits(bmpData);
   
   
  Bitmap bp = new Bitmap(bmp.Width, bmp.Height, PixelFormat.Format24bppRgb);
  Graphics g = Graphics.FromImage(bp);
  g.DrawImage(bmp, new Point(0, 0));
  g.Dispose();
  bmp.Dispose();
   
  .....
   
  

Francisco José <is...@ya...> escribió:
  Parece ser que el formato de 16 bits en escala de grises está roto en el GDI+, cojonudo. La buena noticia es que a 8 bits indexados parece que el tema funciona... pero a color!! siendo la cámara monocromo, en fin, he realizado una burda transformación con la paleta de colores, ya que las funciones setpixel/getpixel no se llevan bien con los 8 bits indexados; a más bits, realmente sólo leía una parte del buffer... muy raro; os paso el extracto del código que funciona, mañana lo intento subir al SVN y mejorar:

Inicialización:

// Buffer de 8bits RAW
            SETBUFFERMODE(1);

Función de captura:

void CapturarClick(object sender, EventArgs e)
        {
                ThreadedExposure((uint)int.Parse(tExposicion.Text), null);
                while(isExposing()!=0)
                {
                    this.mensaje.Text = "Exponiendo...";
                    Console.Write("Exponiendo\n");
                }
                
                // Ahora leemos los datos del buffer
                this.mensaje.Text = "Leyendo datos...";
                
                // El buffer será de 2621440 bytes (16 bits por pixel, 
                // la cámara tiene 1310720 pixels)
                
                PixelFormat format =  PixelFormat.Format8bppIndexed;
                System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
                System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
                GETBUFFER(bmpData.Scan0,1310720);
                bmp.UnlockBits(bmpData);
                            
                
                // Obtención del bitmap
                Bitmap bp = Bitmap8FromUnmanagedArray1(bmpData.Scan0,1280,1024);
                
                // Transformación a escala de grises.
                ColorPalette greyPal = bp.Palette;

                for(int i = 0;i<256;i++)
                {
                    greyPal.Entries[i] = Color.FromArgb(255,i,i,i);
                }
                bp.Palette = greyPal;
                imagenFrame.Image = bp;
                bp.Save(@"c:\test.jpg", ImageFormat.Jpeg);
        }

Creación del bitmap:

 private Bitmap Bitmap8FromUnmanagedArray1(IntPtr image, int width, int height)
        {
            Bitmap bmp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);

            BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);

            IntPtr dest = bmData.Scan0;
            IntPtr source = image;
            int len = width;

            if ( bmData.Stride == len )
            {
                CopyMemory(dest, source, width*height);
            }
            else
            {
                for( int y = 0; y < bmp.Height; y++ )
                {
                    CopyMemory(dest, source, len);

                    source = new IntPtr(source.ToInt32() + len);
                    dest = new IntPtr(dest.ToInt32() + bmData.Stride);
                }
            }
            
            bmp.UnlockBits(bmData);

            return bmp;
        }
    
---------------------------------
  
Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden! .
-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems? Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


 		
---------------------------------

LLama Gratis a cualquier PC del Mundo.
Llamadas a fijos y móviles desde 1 céntimo por minuto.
http://es.voice.yahoo.com

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[<is...@ya...>]

Parece ser que el formato de 16 bits en escala de grises está roto en el GDI+, cojonudo. La buena noticia es que a 8 bits indexados parece que el tema funciona... pero a color!! siendo la cámara monocromo, en fin, he realizado una burda transformación con la paleta de colores, ya que las funciones setpixel/getpixel no se llevan bien con los 8 bits indexados; a más bits, realmente sólo leía una parte del buffer... muy raro; os paso el extracto del código que funciona, mañana lo intento subir al SVN y mejorar:

Inicialización:

// Buffer de 8bits RAW
            SETBUFFERMODE(1);

Función de captura:

void CapturarClick(object sender, EventArgs e)
        {
                ThreadedExposure((uint)int.Parse(tExposicion.Text), null);
                while(isExposing()!=0)
                {
                    this.mensaje.Text = "Exponiendo...";
                    Console.Write("Exponiendo\n");
                }
                
                // Ahora leemos los datos del buffer
                this.mensaje.Text = "Leyendo datos...";
                
                // El buffer será de 2621440 bytes (16 bits por pixel, 
                // la cámara tiene 1310720 pixels)
                
                PixelFormat format =  PixelFormat.Format8bppIndexed;
                System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
                System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, format);
                GETBUFFER(bmpData.Scan0,1310720);
                bmp.UnlockBits(bmpData);
                            
                
                // Obtención del bitmap
                Bitmap bp = Bitmap8FromUnmanagedArray1(bmpData.Scan0,1280,1024);
                
                // Transformación a escala de grises.
                ColorPalette greyPal = bp.Palette;

                for(int i = 0;i<256;i++)
                {
                    greyPal.Entries[i] = Color.FromArgb(255,i,i,i);
                }
                bp.Palette = greyPal;
                imagenFrame.Image = bp;
                bp.Save(@"c:\test.jpg", ImageFormat.Jpeg);
        }

Creación del bitmap:

 private Bitmap Bitmap8FromUnmanagedArray1(IntPtr image, int width, int height)
        {
            Bitmap bmp = new Bitmap(width, height, PixelFormat.Format8bppIndexed);

            BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);

            IntPtr dest = bmData.Scan0;
            IntPtr source = image;
            int len = width;

            if ( bmData.Stride == len )
            {
                CopyMemory(dest, source, width*height);
            }
            else
            {
                for( int y = 0; y < bmp.Height; y++ )
                {
                    CopyMemory(dest, source, len);

                    source = new IntPtr(source.ToInt32() + len);
                    dest = new IntPtr(dest.ToInt32() + bmData.Stride);
                }
            }
            
            bmp.UnlockBits(bmData);

            return bmp;
        }

       
---------------------------------

Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden!.

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[<is...@ya...>]

Bueno, ya he conseguido visualizarla en con control "pictureBox", pero lo que consigo es ver la mitad en verde y la otra mitad en negro (en horizontal).... jesús que cruz, me voy a la cama, mañana más.

Un saludo.

Antonio Fraga <ant...@ya...> escribió: Perfecto, entonces te ahorras el proceso de debayerización, lo más rápido, 
para autoguiar, sería leerla ya en formato de 8bits, para trabajar el 
formato 24bbp (aunque iguales la señal RGB) es más cómodo que el formato 
Format8bbpIndexed.

Venga, ya nos cuentas!

----- Original Message ----- 
From: "Francisco José" 
To: "Lista de correo de desarrollo EQAlign" 

Sent: Thursday, October 04, 2007 11:03 PM
Subject: Re: [Eqalign-devel] Me está dando guerra la QHY


Muchas gracias a los dos por el apoyo; os escribo ma&#347; tarde, sólo un 
comentario, la cámara no
es en color (por suerte, jeje), aunque existe una versión con la matriz 
bayer, me hice de esta por
cuestiones obvias.

Entonces, supongo, todo quedará igual pero sin el proceso de 
"debayerización", algo más simple ¿me
equivoco?.

El driver permite obtener el buffer bien en 8 bits o en 16 (podéis ver la 
documentación en
mensajes anteriores), creo que para optimizar velocidad y memoria sería 
mejor trabajar con 8 bits
¿cierto?.

Una curiosidad, como la cámara se la compré al chino directamente (a parte 
de que me costó 1/3 de
lo que cuesta en España ¿llegará el coste de producción real a los 30 
euros?...) yo la reprogramé
y realmente el pc la reconoce como la QGuider de CCDLabs, jejeje.

En fin , vuelvo en un rato, cuando haga algunas pruebas.

Un abrazo a ambos.
--- Antonio Fraga  escribió:

> Entonces quedamos que una cosa es capturar una imagen para guardarla en 16
> bits y otra representarla en un Picturebox, por ejemplo o enviársela al
> sistema de representación de imágenes de Camera.cs para autoguiar. Para 
> esto
> último, primero tenemos que debayizar la imagen directamente en un Bitmap
> 24bbp. Para guardar la imagen lo mejor sería usar FreeImage, crear un
> contendor de 48bpp para "debayerizarla" (joé con el palabro) ahí.
>
> No sé que máscara bayer tiene la Luna (normalmente será RGGB, GRBG, BRGR,
> GBRB, en una ventana cuadrada)
>
> Ya de entrada para saber si estás leyendo bien la imagen, podrías pasarla 
> a
> 24bbp y representarla en un picturebox sin decodificarla (oiga), así:
>
>       Bitmap newImg = new Bitmap(Width, Height,
> System.Drawing.Imaging.PixelFormat.Format24bppRgb);
>       Graphics g = Graphics.FromImage(newImg);
>       g.DrawImage(lunaImg, new Point(0,0));
>       g.Dispose();
>       picturebox1.Image = newImg;
>       lunaImg.Dispose();
>
> Así sabrás si la cosa va bien. Si es así, entonces debes crearte un
> algoritmo de decodificación hacia un Bitmap de 24bbp.
>
> Te envío un trozo de código que decodifica una imagen raw con microfiltros
> RGB, pero está pensado para una imagen RGBImage que se representa en una
> estructura:
> private float[] data;
>
> , en formato de rango {0.0f, 1.0f} (una caca de óptimo, lo sé).
>
> Para trabajar directamente con Bitmaps sería algo parecido y más óptimo si
> bloqueas la imagen con LockBits para trabajar directamente en memoria.
> Además, sabiendo la máscara de bayer correcta, puedes reescribir el código
> específico, el código que te envío es genérico.
>
> Bueno, ya nos cuentas.
> Un saludo
>
> -----------------------------------------------------------------------------------------------
>     public void DeBayerRGB(int idxBayerMatrix)
>     {
>       // 0=B 1=G 2=R
>       // RGGB GRBG GBRG BGGR
>       int[, ,] bMatrix = { { { 2, 1 }, { 1, 0 } },
>                            { { 1, 2 }, { 0, 1 } },
>                            { { 1, 0 }, { 2, 1 } },
>                            { { 0, 1 }, { 1, 2 } } };
>       int[,] bSubMatrix = { { 0, 0 }, { 0, 0 } }; //ventana
>       int npix = this.height * this.width * 3;  //tamaño del buffer
>       float[] data2 = new float[npix];   //nuevo datos de la imagen float
>
>       int x, y;
>       int idx, idx0, idx1;
>       int idxR = 0, idxG = 0, idxB = 0;
>       int[,] idxC = { { 0, 0 }, { 0, 0 } };
>
>       for (y = 0, idx = 0; y < this.height - 2; y++)
>       {
>         int l = y % 2;   //fila par o impar
>         int l2 = (l == 0 ? 1 : 0);
>
>         idx0 = y * this.stride;  //índice a la fila actual
>         idx1 = idx0 + this.stride; //índice a la siguiente
>
>         for (x = 0; x < this.width - 1; x++, idx += 3)
>         {
>           int c = x % 2;  //columna par o impar
>           int c2 = (c == 0 ? 1 : 0);
>
>           int[,] bidx = { { 0, 0 }, { 0, 0 } };  //índices a lo píxeles de
> la ventana
>           bidx[0, 0] = idx0 + x * this.ColorPlanes; //sobra: ColorPlanes = 
> 1
> (imagen en grises)
>           bidx[0, 1] = bidx[0, 0] + this.ColorPlanes;
>           bidx[1, 0] = idx1 + x * this.ColorPlanes;
>           bidx[1, 1] = bidx[1, 0] + this.ColorPlanes;
>
>    //bSubMatrix contendrá la ventana de bayer
>           bSubMatrix[0, 0] = bMatrix[idxBayerMatrix, l, c];
>           bSubMatrix[0, 1] = bMatrix[idxBayerMatrix, l, c2];
>           bSubMatrix[1, 0] = bMatrix[idxBayerMatrix, l2, c];
>           bSubMatrix[1, 1] = bMatrix[idxBayerMatrix, l2, c2];
>
>    //ahora a componer el color!! ... dependiendo del pixel donde estemos
>           float[] C = { 0, 0, 0 };
>           float[] nC = { 0, 0, 0 };
>           for (int by = 0; by < 2; by++)
>             for (int bx = 0; bx < 2; bx++)
>             {
>               C[bSubMatrix[by, bx]] += this.data[bidx[by, bx]]; //aquí l
>               nC[bSubMatrix[by, bx]]++;
>             }
>    //compensación de la contribución de cada color en la ventana, nC[i] es
> el peso del canal i
>           for (int ic = 0; ic < 3; ic++) C[ic] = C[ic] / nC[ic];
>
>
>           data2[idx] = C[0];  //B
>           data2[idx + 1] = C[1]; //G
>           data2[idx + 2] = C[2]; //R
>         }
>         idx += 3;
>       }
>
>       this.ColorPlanes = 3;
>       this.stride = this.width * this.ColorPlanes;
>       this.data = null;
>       this.data = data2;
>
>     }
>
> -----------------------------------------------------------------------------------------------
>
> ----- Original Message ----- 
> From: "Antonio Fraga" 
> To: "Lista de correo de desarrollo EQAlign"
> 
> Sent: Thursday, October 04, 2007 7:36 PM
> Subject: Re: [Eqalign-devel] Me está dando guerra la QHY
>
>
> Este tema del GDI es muy interesante!!, lo siento chicos, me incorporo al
> hilo en un par de horas, ahora sólo tuve tiempo de leer el correo pero es 
> la
> hora del baño-cena-cuento-cama de Matías, el ritual de todos los días :-))
>
> Sólo una cosa, hasta donde pude averiguar el GDI no permite guardar TIFF 
> 16,
> en su día me hice con las librerías de FreeImage para eso; pero si, por
> ahora, lo que queremos es captarla como cámara guía, lo que tenemos que
> hacer es convertir el formato de profundidad de bit 16 a profundidad 8.
>
> Otra cosa más, la Luna es en color ¿no?, al recogerlo en un formato de
> 16bits grayscale, como debe ser, lo que vas a tener es una imagen RAW como
> dices, con la matriz de bayer bien clarita. Lo primero que hay que hacer 
> es
> "debayerizarla", también tengo código para eso.
>
> Y otra cosa, en el proyecto hay un miniplanteamiento de una clase de tipo
> FloatImage, aunque sería más lento, si lo que se quiere es guardar la 
> imagen
> en 16bits, se puede utilizar como "trampolín" al FreeImage. Es más lento
> porque el buffer de FreeImage es más óptimo, pero en ese formato (el de
> FloatImage) tengo diseñados algunos filtros: estadísticos
> (mediana/media/stddev) histogramas, curvas, rotaciones, remuestreos,
> desenfoques, unsharpmask, DDP,... aunque se puede utilizar FreeImage
> directamente (que también también implementa algunos tratamientos básicos 
> en
> 32 bits) y dejar el proceso a un programa especializado... como debe ser.
>
> En fin, luego sigo con calma.
>
> ----- Original Message ----- 
> From: "Andres del Pozo Prieto" 
> To: "Lista de correo de desarrollo EQAlign"
> 
> Sent: Thursday, October 04, 2007 6:31 PM
> Subject: Re: [Eqalign-devel] Me está dando guerra la QHY
>
>
> Francisco José wrote:
> > Pues eso, hartito me tiene... os planteo otra duda, a ver, tengo este
> > código:
> >
> > // El buffer será de 2621440 bytes (16 bits por pixel,
> >                 // la cámara tiene 1310720 pixels)
> >                 PixelFormat format =  PixelFormat.Format16bppGrayScale;
> >                 System.Drawing.Bitmap bmp = new
> > System.Drawing.Bitmap(1280, 1024, format);
> >                 System.Drawing.Imaging.BitmapData bmpData =
> > bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width,
> > bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, format);
> >                 GETBUFFER(bmpData.Scan0,1310720);
> >                 bmp.UnlockBits(bmpData);
> >
> > Entiendo que en bmpData.Scan0 tengo el comienzo de la imagen RAW ¿y
> > ahora qué he de realizar para obtener la imagen? Si intento guardar o
> > fijarla a un control PictureBox me dice que el argumento es inválido
> > en una excepción en tiempo de ejecución, por ejemplo:
> >
> >  bmp.Save(@"c:\test.bmp", ImageFormat.Bmp);
> Si no recuerdo mal el formato BMP no admite el formato de greyscale de
> 16bits. Puedes probar si te lo guarda en formato TIFF.
>
> > Ya mareado, y siendo honesto, he localizado en una web este código,
> > pero genera imágenes de 32bits RGB, logro guardar la imagen pero
> > claro, la cámara es monocromo y a 16:
> >
> > [DllImport("kernel32.dll")]
> >         private static extern uint CopyMemory (IntPtr dest, IntPtr
> > Source, int Length);
> >
> >         private Bitmap Bitmap32FromUnmanagedArray1(IntPtr image, int
> > width, int height)
> >         {
> >             Bitmap bmp = new Bitmap(width, height,
> > PixelFormat.Format32bppRgb);
> >
> >             BitmapData bmData = bmp.LockBits(new Rectangle(0, 0,
> > bmp.Width, bmp.Height),
> >                 ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
> >
> >             IntPtr dest = bmData.Scan0;
> >             IntPtr source = image;
> >             int len = width*4;
>
=== message truncated ===




____________________________________________________________________________________
Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden!
http://advision.webevents.yahoo.com/reto/entretenimiento.html


-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems?  Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/
_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel 


-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems?  Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/
_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


       
---------------------------------

Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden!.

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[Antonio F. <ant...@ya...>]

Perfecto, entonces te ahorras el proceso de debayerización, lo más rápido, 
para autoguiar, sería leerla ya en formato de 8bits, para trabajar el 
formato 24bbp (aunque iguales la señal RGB) es más cómodo que el formato 
Format8bbpIndexed.

Venga, ya nos cuentas!

----- Original Message ----- 
From: "Francisco José" <is...@ya...>
To: "Lista de correo de desarrollo EQAlign" 
<eqa...@li...>
Sent: Thursday, October 04, 2007 11:03 PM
Subject: Re: [Eqalign-devel] Me está dando guerra la QHY


Muchas gracias a los dos por el apoyo; os escribo ma&#347; tarde, sólo un 
comentario, la cámara no
es en color (por suerte, jeje), aunque existe una versión con la matriz 
bayer, me hice de esta por
cuestiones obvias.

Entonces, supongo, todo quedará igual pero sin el proceso de 
"debayerización", algo más simple ¿me
equivoco?.

El driver permite obtener el buffer bien en 8 bits o en 16 (podéis ver la 
documentación en
mensajes anteriores), creo que para optimizar velocidad y memoria sería 
mejor trabajar con 8 bits
¿cierto?.

Una curiosidad, como la cámara se la compré al chino directamente (a parte 
de que me costó 1/3 de
lo que cuesta en España ¿llegará el coste de producción real a los 30 
euros?...) yo la reprogramé
y realmente el pc la reconoce como la QGuider de CCDLabs, jejeje.

En fin , vuelvo en un rato, cuando haga algunas pruebas.

Un abrazo a ambos.
--- Antonio Fraga <ant...@ya...> escribió:

> Entonces quedamos que una cosa es capturar una imagen para guardarla en 16
> bits y otra representarla en un Picturebox, por ejemplo o enviársela al
> sistema de representación de imágenes de Camera.cs para autoguiar. Para 
> esto
> último, primero tenemos que debayizar la imagen directamente en un Bitmap
> 24bbp. Para guardar la imagen lo mejor sería usar FreeImage, crear un
> contendor de 48bpp para "debayerizarla" (joé con el palabro) ahí.
>
> No sé que máscara bayer tiene la Luna (normalmente será RGGB, GRBG, BRGR,
> GBRB, en una ventana cuadrada)
>
> Ya de entrada para saber si estás leyendo bien la imagen, podrías pasarla 
> a
> 24bbp y representarla en un picturebox sin decodificarla (oiga), así:
>
>       Bitmap newImg = new Bitmap(Width, Height,
> System.Drawing.Imaging.PixelFormat.Format24bppRgb);
>       Graphics g = Graphics.FromImage(newImg);
>       g.DrawImage(lunaImg, new Point(0,0));
>       g.Dispose();
>       picturebox1.Image = newImg;
>       lunaImg.Dispose();
>
> Así sabrás si la cosa va bien. Si es así, entonces debes crearte un
> algoritmo de decodificación hacia un Bitmap de 24bbp.
>
> Te envío un trozo de código que decodifica una imagen raw con microfiltros
> RGB, pero está pensado para una imagen RGBImage que se representa en una
> estructura:
> private float[] data;
>
> , en formato de rango {0.0f, 1.0f} (una caca de óptimo, lo sé).
>
> Para trabajar directamente con Bitmaps sería algo parecido y más óptimo si
> bloqueas la imagen con LockBits para trabajar directamente en memoria.
> Además, sabiendo la máscara de bayer correcta, puedes reescribir el código
> específico, el código que te envío es genérico.
>
> Bueno, ya nos cuentas.
> Un saludo
>
> -----------------------------------------------------------------------------------------------
>     public void DeBayerRGB(int idxBayerMatrix)
>     {
>       // 0=B 1=G 2=R
>       // RGGB GRBG GBRG BGGR
>       int[, ,] bMatrix = { { { 2, 1 }, { 1, 0 } },
>                            { { 1, 2 }, { 0, 1 } },
>                            { { 1, 0 }, { 2, 1 } },
>                            { { 0, 1 }, { 1, 2 } } };
>       int[,] bSubMatrix = { { 0, 0 }, { 0, 0 } }; //ventana
>       int npix = this.height * this.width * 3;  //tamaño del buffer
>       float[] data2 = new float[npix];   //nuevo datos de la imagen float
>
>       int x, y;
>       int idx, idx0, idx1;
>       int idxR = 0, idxG = 0, idxB = 0;
>       int[,] idxC = { { 0, 0 }, { 0, 0 } };
>
>       for (y = 0, idx = 0; y < this.height - 2; y++)
>       {
>         int l = y % 2;   //fila par o impar
>         int l2 = (l == 0 ? 1 : 0);
>
>         idx0 = y * this.stride;  //índice a la fila actual
>         idx1 = idx0 + this.stride; //índice a la siguiente
>
>         for (x = 0; x < this.width - 1; x++, idx += 3)
>         {
>           int c = x % 2;  //columna par o impar
>           int c2 = (c == 0 ? 1 : 0);
>
>           int[,] bidx = { { 0, 0 }, { 0, 0 } };  //índices a lo píxeles de
> la ventana
>           bidx[0, 0] = idx0 + x * this.ColorPlanes; //sobra: ColorPlanes = 
> 1
> (imagen en grises)
>           bidx[0, 1] = bidx[0, 0] + this.ColorPlanes;
>           bidx[1, 0] = idx1 + x * this.ColorPlanes;
>           bidx[1, 1] = bidx[1, 0] + this.ColorPlanes;
>
>    //bSubMatrix contendrá la ventana de bayer
>           bSubMatrix[0, 0] = bMatrix[idxBayerMatrix, l, c];
>           bSubMatrix[0, 1] = bMatrix[idxBayerMatrix, l, c2];
>           bSubMatrix[1, 0] = bMatrix[idxBayerMatrix, l2, c];
>           bSubMatrix[1, 1] = bMatrix[idxBayerMatrix, l2, c2];
>
>    //ahora a componer el color!! ... dependiendo del pixel donde estemos
>           float[] C = { 0, 0, 0 };
>           float[] nC = { 0, 0, 0 };
>           for (int by = 0; by < 2; by++)
>             for (int bx = 0; bx < 2; bx++)
>             {
>               C[bSubMatrix[by, bx]] += this.data[bidx[by, bx]]; //aquí l
>               nC[bSubMatrix[by, bx]]++;
>             }
>    //compensación de la contribución de cada color en la ventana, nC[i] es
> el peso del canal i
>           for (int ic = 0; ic < 3; ic++) C[ic] = C[ic] / nC[ic];
>
>
>           data2[idx] = C[0];  //B
>           data2[idx + 1] = C[1]; //G
>           data2[idx + 2] = C[2]; //R
>         }
>         idx += 3;
>       }
>
>       this.ColorPlanes = 3;
>       this.stride = this.width * this.ColorPlanes;
>       this.data = null;
>       this.data = data2;
>
>     }
>
> -----------------------------------------------------------------------------------------------
>
> ----- Original Message ----- 
> From: "Antonio Fraga" <ant...@ya...>
> To: "Lista de correo de desarrollo EQAlign"
> <eqa...@li...>
> Sent: Thursday, October 04, 2007 7:36 PM
> Subject: Re: [Eqalign-devel] Me está dando guerra la QHY
>
>
> Este tema del GDI es muy interesante!!, lo siento chicos, me incorporo al
> hilo en un par de horas, ahora sólo tuve tiempo de leer el correo pero es 
> la
> hora del baño-cena-cuento-cama de Matías, el ritual de todos los días :-))
>
> Sólo una cosa, hasta donde pude averiguar el GDI no permite guardar TIFF 
> 16,
> en su día me hice con las librerías de FreeImage para eso; pero si, por
> ahora, lo que queremos es captarla como cámara guía, lo que tenemos que
> hacer es convertir el formato de profundidad de bit 16 a profundidad 8.
>
> Otra cosa más, la Luna es en color ¿no?, al recogerlo en un formato de
> 16bits grayscale, como debe ser, lo que vas a tener es una imagen RAW como
> dices, con la matriz de bayer bien clarita. Lo primero que hay que hacer 
> es
> "debayerizarla", también tengo código para eso.
>
> Y otra cosa, en el proyecto hay un miniplanteamiento de una clase de tipo
> FloatImage, aunque sería más lento, si lo que se quiere es guardar la 
> imagen
> en 16bits, se puede utilizar como "trampolín" al FreeImage. Es más lento
> porque el buffer de FreeImage es más óptimo, pero en ese formato (el de
> FloatImage) tengo diseñados algunos filtros: estadísticos
> (mediana/media/stddev) histogramas, curvas, rotaciones, remuestreos,
> desenfoques, unsharpmask, DDP,... aunque se puede utilizar FreeImage
> directamente (que también también implementa algunos tratamientos básicos 
> en
> 32 bits) y dejar el proceso a un programa especializado... como debe ser.
>
> En fin, luego sigo con calma.
>
> ----- Original Message ----- 
> From: "Andres del Pozo Prieto" <and...@gm...>
> To: "Lista de correo de desarrollo EQAlign"
> <eqa...@li...>
> Sent: Thursday, October 04, 2007 6:31 PM
> Subject: Re: [Eqalign-devel] Me está dando guerra la QHY
>
>
> Francisco José wrote:
> > Pues eso, hartito me tiene... os planteo otra duda, a ver, tengo este
> > código:
> >
> > // El buffer será de 2621440 bytes (16 bits por pixel,
> >                 // la cámara tiene 1310720 pixels)
> >                 PixelFormat format =  PixelFormat.Format16bppGrayScale;
> >                 System.Drawing.Bitmap bmp = new
> > System.Drawing.Bitmap(1280, 1024, format);
> >                 System.Drawing.Imaging.BitmapData bmpData =
> > bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width,
> > bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, format);
> >                 GETBUFFER(bmpData.Scan0,1310720);
> >                 bmp.UnlockBits(bmpData);
> >
> > Entiendo que en bmpData.Scan0 tengo el comienzo de la imagen RAW ¿y
> > ahora qué he de realizar para obtener la imagen? Si intento guardar o
> > fijarla a un control PictureBox me dice que el argumento es inválido
> > en una excepción en tiempo de ejecución, por ejemplo:
> >
> >  bmp.Save(@"c:\test.bmp", ImageFormat.Bmp);
> Si no recuerdo mal el formato BMP no admite el formato de greyscale de
> 16bits. Puedes probar si te lo guarda en formato TIFF.
>
> > Ya mareado, y siendo honesto, he localizado en una web este código,
> > pero genera imágenes de 32bits RGB, logro guardar la imagen pero
> > claro, la cámara es monocromo y a 16:
> >
> > [DllImport("kernel32.dll")]
> >         private static extern uint CopyMemory (IntPtr dest, IntPtr
> > Source, int Length);
> >
> >         private Bitmap Bitmap32FromUnmanagedArray1(IntPtr image, int
> > width, int height)
> >         {
> >             Bitmap bmp = new Bitmap(width, height,
> > PixelFormat.Format32bppRgb);
> >
> >             BitmapData bmData = bmp.LockBits(new Rectangle(0, 0,
> > bmp.Width, bmp.Height),
> >                 ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
> >
> >             IntPtr dest = bmData.Scan0;
> >             IntPtr source = image;
> >             int len = width*4;
>
=== message truncated ===




____________________________________________________________________________________
Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden!
http://advision.webevents.yahoo.com/reto/entretenimiento.html


-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems?  Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/
_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel 

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[<is...@ya...>]

Muchas gracias a los dos por el apoyo; os escribo maś tarde, sólo un comentario, la cámara no
es en color (por suerte, jeje), aunque existe una versión con la matriz bayer, me hice de esta por
cuestiones obvias.

Entonces, supongo, todo quedará igual pero sin el proceso de "debayerización", algo más simple ¿me
equivoco?.

El driver permite obtener el buffer bien en 8 bits o en 16 (podéis ver la documentación en
mensajes anteriores), creo que para optimizar velocidad y memoria sería mejor trabajar con 8 bits
¿cierto?.

Una curiosidad, como la cámara se la compré al chino directamente (a parte de que me costó 1/3 de
lo que cuesta en España ¿llegará el coste de producción real a los 30 euros?...) yo la reprogramé
y realmente el pc la reconoce como la QGuider de CCDLabs, jejeje.

En fin , vuelvo en un rato, cuando haga algunas pruebas.

Un abrazo a ambos.
--- Antonio Fraga <ant...@ya...> escribió:

> Entonces quedamos que una cosa es capturar una imagen para guardarla en 16 
> bits y otra representarla en un Picturebox, por ejemplo o enviársela al 
> sistema de representación de imágenes de Camera.cs para autoguiar. Para esto 
> último, primero tenemos que debayizar la imagen directamente en un Bitmap 
> 24bbp. Para guardar la imagen lo mejor sería usar FreeImage, crear un 
> contendor de 48bpp para "debayerizarla" (joé con el palabro) ahí.
> 
> No sé que máscara bayer tiene la Luna (normalmente será RGGB, GRBG, BRGR, 
> GBRB, en una ventana cuadrada)
> 
> Ya de entrada para saber si estás leyendo bien la imagen, podrías pasarla a 
> 24bbp y representarla en un picturebox sin decodificarla (oiga), así:
> 
>       Bitmap newImg = new Bitmap(Width, Height, 
> System.Drawing.Imaging.PixelFormat.Format24bppRgb);
>       Graphics g = Graphics.FromImage(newImg);
>       g.DrawImage(lunaImg, new Point(0,0));
>       g.Dispose();
>       picturebox1.Image = newImg;
>       lunaImg.Dispose();
> 
> Así sabrás si la cosa va bien. Si es así, entonces debes crearte un 
> algoritmo de decodificación hacia un Bitmap de 24bbp.
> 
> Te envío un trozo de código que decodifica una imagen raw con microfiltros 
> RGB, pero está pensado para una imagen RGBImage que se representa en una 
> estructura:
> private float[] data;
> 
> , en formato de rango {0.0f, 1.0f} (una caca de óptimo, lo sé).
> 
> Para trabajar directamente con Bitmaps sería algo parecido y más óptimo si 
> bloqueas la imagen con LockBits para trabajar directamente en memoria.
> Además, sabiendo la máscara de bayer correcta, puedes reescribir el código 
> específico, el código que te envío es genérico.
> 
> Bueno, ya nos cuentas.
> Un saludo
> 
> -----------------------------------------------------------------------------------------------
>     public void DeBayerRGB(int idxBayerMatrix)
>     {
>       // 0=B 1=G 2=R
>       // RGGB GRBG GBRG BGGR
>       int[, ,] bMatrix = { { { 2, 1 }, { 1, 0 } },
>                            { { 1, 2 }, { 0, 1 } },
>                            { { 1, 0 }, { 2, 1 } },
>                            { { 0, 1 }, { 1, 2 } } };
>       int[,] bSubMatrix = { { 0, 0 }, { 0, 0 } }; //ventana
>       int npix = this.height * this.width * 3;  //tamaño del buffer
>       float[] data2 = new float[npix];   //nuevo datos de la imagen float
> 
>       int x, y;
>       int idx, idx0, idx1;
>       int idxR = 0, idxG = 0, idxB = 0;
>       int[,] idxC = { { 0, 0 }, { 0, 0 } };
> 
>       for (y = 0, idx = 0; y < this.height - 2; y++)
>       {
>         int l = y % 2;   //fila par o impar
>         int l2 = (l == 0 ? 1 : 0);
> 
>         idx0 = y * this.stride;  //índice a la fila actual
>         idx1 = idx0 + this.stride; //índice a la siguiente
> 
>         for (x = 0; x < this.width - 1; x++, idx += 3)
>         {
>           int c = x % 2;  //columna par o impar
>           int c2 = (c == 0 ? 1 : 0);
> 
>           int[,] bidx = { { 0, 0 }, { 0, 0 } };  //índices a lo píxeles de 
> la ventana
>           bidx[0, 0] = idx0 + x * this.ColorPlanes; //sobra: ColorPlanes = 1 
> (imagen en grises)
>           bidx[0, 1] = bidx[0, 0] + this.ColorPlanes;
>           bidx[1, 0] = idx1 + x * this.ColorPlanes;
>           bidx[1, 1] = bidx[1, 0] + this.ColorPlanes;
> 
>    //bSubMatrix contendrá la ventana de bayer
>           bSubMatrix[0, 0] = bMatrix[idxBayerMatrix, l, c];
>           bSubMatrix[0, 1] = bMatrix[idxBayerMatrix, l, c2];
>           bSubMatrix[1, 0] = bMatrix[idxBayerMatrix, l2, c];
>           bSubMatrix[1, 1] = bMatrix[idxBayerMatrix, l2, c2];
> 
>    //ahora a componer el color!! ... dependiendo del pixel donde estemos
>           float[] C = { 0, 0, 0 };
>           float[] nC = { 0, 0, 0 };
>           for (int by = 0; by < 2; by++)
>             for (int bx = 0; bx < 2; bx++)
>             {
>               C[bSubMatrix[by, bx]] += this.data[bidx[by, bx]]; //aquí l
>               nC[bSubMatrix[by, bx]]++;
>             }
>    //compensación de la contribución de cada color en la ventana, nC[i] es 
> el peso del canal i
>           for (int ic = 0; ic < 3; ic++) C[ic] = C[ic] / nC[ic];
> 
> 
>           data2[idx] = C[0];  //B
>           data2[idx + 1] = C[1]; //G
>           data2[idx + 2] = C[2]; //R
>         }
>         idx += 3;
>       }
> 
>       this.ColorPlanes = 3;
>       this.stride = this.width * this.ColorPlanes;
>       this.data = null;
>       this.data = data2;
> 
>     }
> 
> -----------------------------------------------------------------------------------------------
> 
> ----- Original Message ----- 
> From: "Antonio Fraga" <ant...@ya...>
> To: "Lista de correo de desarrollo EQAlign" 
> <eqa...@li...>
> Sent: Thursday, October 04, 2007 7:36 PM
> Subject: Re: [Eqalign-devel] Me está dando guerra la QHY
> 
> 
> Este tema del GDI es muy interesante!!, lo siento chicos, me incorporo al
> hilo en un par de horas, ahora sólo tuve tiempo de leer el correo pero es la
> hora del baño-cena-cuento-cama de Matías, el ritual de todos los días :-))
> 
> Sólo una cosa, hasta donde pude averiguar el GDI no permite guardar TIFF 16,
> en su día me hice con las librerías de FreeImage para eso; pero si, por
> ahora, lo que queremos es captarla como cámara guía, lo que tenemos que
> hacer es convertir el formato de profundidad de bit 16 a profundidad 8.
> 
> Otra cosa más, la Luna es en color ¿no?, al recogerlo en un formato de
> 16bits grayscale, como debe ser, lo que vas a tener es una imagen RAW como
> dices, con la matriz de bayer bien clarita. Lo primero que hay que hacer es
> "debayerizarla", también tengo código para eso.
> 
> Y otra cosa, en el proyecto hay un miniplanteamiento de una clase de tipo
> FloatImage, aunque sería más lento, si lo que se quiere es guardar la imagen
> en 16bits, se puede utilizar como "trampolín" al FreeImage. Es más lento
> porque el buffer de FreeImage es más óptimo, pero en ese formato (el de
> FloatImage) tengo diseñados algunos filtros: estadísticos
> (mediana/media/stddev) histogramas, curvas, rotaciones, remuestreos,
> desenfoques, unsharpmask, DDP,... aunque se puede utilizar FreeImage
> directamente (que también también implementa algunos tratamientos básicos en
> 32 bits) y dejar el proceso a un programa especializado... como debe ser.
> 
> En fin, luego sigo con calma.
> 
> ----- Original Message ----- 
> From: "Andres del Pozo Prieto" <and...@gm...>
> To: "Lista de correo de desarrollo EQAlign"
> <eqa...@li...>
> Sent: Thursday, October 04, 2007 6:31 PM
> Subject: Re: [Eqalign-devel] Me está dando guerra la QHY
> 
> 
> Francisco José wrote:
> > Pues eso, hartito me tiene... os planteo otra duda, a ver, tengo este
> > código:
> >
> > // El buffer será de 2621440 bytes (16 bits por pixel,
> >                 // la cámara tiene 1310720 pixels)
> >                 PixelFormat format =  PixelFormat.Format16bppGrayScale;
> >                 System.Drawing.Bitmap bmp = new
> > System.Drawing.Bitmap(1280, 1024, format);
> >                 System.Drawing.Imaging.BitmapData bmpData =
> > bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width,
> > bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, format);
> >                 GETBUFFER(bmpData.Scan0,1310720);
> >                 bmp.UnlockBits(bmpData);
> >
> > Entiendo que en bmpData.Scan0 tengo el comienzo de la imagen RAW ¿y
> > ahora qué he de realizar para obtener la imagen? Si intento guardar o
> > fijarla a un control PictureBox me dice que el argumento es inválido
> > en una excepción en tiempo de ejecución, por ejemplo:
> >
> >  bmp.Save(@"c:\test.bmp", ImageFormat.Bmp);
> Si no recuerdo mal el formato BMP no admite el formato de greyscale de
> 16bits. Puedes probar si te lo guarda en formato TIFF.
> 
> > Ya mareado, y siendo honesto, he localizado en una web este código,
> > pero genera imágenes de 32bits RGB, logro guardar la imagen pero
> > claro, la cámara es monocromo y a 16:
> >
> > [DllImport("kernel32.dll")]
> >         private static extern uint CopyMemory (IntPtr dest, IntPtr
> > Source, int Length);
> >
> >         private Bitmap Bitmap32FromUnmanagedArray1(IntPtr image, int
> > width, int height)
> >         {
> >             Bitmap bmp = new Bitmap(width, height,
> > PixelFormat.Format32bppRgb);
> >
> >             BitmapData bmData = bmp.LockBits(new Rectangle(0, 0,
> > bmp.Width, bmp.Height),
> >                 ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
> >
> >             IntPtr dest = bmData.Scan0;
> >             IntPtr source = image;
> >             int len = width*4;
> 
=== message truncated ===



       
____________________________________________________________________________________
Sé un Mejor Amante del Cine                         
¿Quieres saber cómo? ¡Deja que otras personas te ayuden!
http://advision.webevents.yahoo.com/reto/entretenimiento.html

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[Antonio F. <ant...@ya...>]

Entonces quedamos que una cosa es capturar una imagen para guardarla en 16 
bits y otra representarla en un Picturebox, por ejemplo o enviársela al 
sistema de representación de imágenes de Camera.cs para autoguiar. Para esto 
último, primero tenemos que debayizar la imagen directamente en un Bitmap 
24bbp. Para guardar la imagen lo mejor sería usar FreeImage, crear un 
contendor de 48bpp para "debayerizarla" (joé con el palabro) ahí.

No sé que máscara bayer tiene la Luna (normalmente será RGGB, GRBG, BRGR, 
GBRB, en una ventana cuadrada)

Ya de entrada para saber si estás leyendo bien la imagen, podrías pasarla a 
24bbp y representarla en un picturebox sin decodificarla (oiga), así:

      Bitmap newImg = new Bitmap(Width, Height, 
System.Drawing.Imaging.PixelFormat.Format24bppRgb);
      Graphics g = Graphics.FromImage(newImg);
      g.DrawImage(lunaImg, new Point(0,0));
      g.Dispose();
      picturebox1.Image = newImg;
      lunaImg.Dispose();

Así sabrás si la cosa va bien. Si es así, entonces debes crearte un 
algoritmo de decodificación hacia un Bitmap de 24bbp.

Te envío un trozo de código que decodifica una imagen raw con microfiltros 
RGB, pero está pensado para una imagen RGBImage que se representa en una 
estructura:
private float[] data;

, en formato de rango {0.0f, 1.0f} (una caca de óptimo, lo sé).

Para trabajar directamente con Bitmaps sería algo parecido y más óptimo si 
bloqueas la imagen con LockBits para trabajar directamente en memoria.
Además, sabiendo la máscara de bayer correcta, puedes reescribir el código 
específico, el código que te envío es genérico.

Bueno, ya nos cuentas.
Un saludo

-----------------------------------------------------------------------------------------------
    public void DeBayerRGB(int idxBayerMatrix)
    {
      // 0=B 1=G 2=R
      // RGGB GRBG GBRG BGGR
      int[, ,] bMatrix = { { { 2, 1 }, { 1, 0 } },
                           { { 1, 2 }, { 0, 1 } },
                           { { 1, 0 }, { 2, 1 } },
                           { { 0, 1 }, { 1, 2 } } };
      int[,] bSubMatrix = { { 0, 0 }, { 0, 0 } }; //ventana
      int npix = this.height * this.width * 3;  //tamaño del buffer
      float[] data2 = new float[npix];   //nuevo datos de la imagen float

      int x, y;
      int idx, idx0, idx1;
      int idxR = 0, idxG = 0, idxB = 0;
      int[,] idxC = { { 0, 0 }, { 0, 0 } };

      for (y = 0, idx = 0; y < this.height - 2; y++)
      {
        int l = y % 2;   //fila par o impar
        int l2 = (l == 0 ? 1 : 0);

        idx0 = y * this.stride;  //índice a la fila actual
        idx1 = idx0 + this.stride; //índice a la siguiente

        for (x = 0; x < this.width - 1; x++, idx += 3)
        {
          int c = x % 2;  //columna par o impar
          int c2 = (c == 0 ? 1 : 0);

          int[,] bidx = { { 0, 0 }, { 0, 0 } };  //índices a lo píxeles de 
la ventana
          bidx[0, 0] = idx0 + x * this.ColorPlanes; //sobra: ColorPlanes = 1 
(imagen en grises)
          bidx[0, 1] = bidx[0, 0] + this.ColorPlanes;
          bidx[1, 0] = idx1 + x * this.ColorPlanes;
          bidx[1, 1] = bidx[1, 0] + this.ColorPlanes;

   //bSubMatrix contendrá la ventana de bayer
          bSubMatrix[0, 0] = bMatrix[idxBayerMatrix, l, c];
          bSubMatrix[0, 1] = bMatrix[idxBayerMatrix, l, c2];
          bSubMatrix[1, 0] = bMatrix[idxBayerMatrix, l2, c];
          bSubMatrix[1, 1] = bMatrix[idxBayerMatrix, l2, c2];

   //ahora a componer el color!! ... dependiendo del pixel donde estemos
          float[] C = { 0, 0, 0 };
          float[] nC = { 0, 0, 0 };
          for (int by = 0; by < 2; by++)
            for (int bx = 0; bx < 2; bx++)
            {
              C[bSubMatrix[by, bx]] += this.data[bidx[by, bx]]; //aquí l
              nC[bSubMatrix[by, bx]]++;
            }
   //compensación de la contribución de cada color en la ventana, nC[i] es 
el peso del canal i
          for (int ic = 0; ic < 3; ic++) C[ic] = C[ic] / nC[ic];


          data2[idx] = C[0];  //B
          data2[idx + 1] = C[1]; //G
          data2[idx + 2] = C[2]; //R
        }
        idx += 3;
      }

      this.ColorPlanes = 3;
      this.stride = this.width * this.ColorPlanes;
      this.data = null;
      this.data = data2;

    }

-----------------------------------------------------------------------------------------------

----- Original Message ----- 
From: "Antonio Fraga" <ant...@ya...>
To: "Lista de correo de desarrollo EQAlign" 
<eqa...@li...>
Sent: Thursday, October 04, 2007 7:36 PM
Subject: Re: [Eqalign-devel] Me está dando guerra la QHY


Este tema del GDI es muy interesante!!, lo siento chicos, me incorporo al
hilo en un par de horas, ahora sólo tuve tiempo de leer el correo pero es la
hora del baño-cena-cuento-cama de Matías, el ritual de todos los días :-))

Sólo una cosa, hasta donde pude averiguar el GDI no permite guardar TIFF 16,
en su día me hice con las librerías de FreeImage para eso; pero si, por
ahora, lo que queremos es captarla como cámara guía, lo que tenemos que
hacer es convertir el formato de profundidad de bit 16 a profundidad 8.

Otra cosa más, la Luna es en color ¿no?, al recogerlo en un formato de
16bits grayscale, como debe ser, lo que vas a tener es una imagen RAW como
dices, con la matriz de bayer bien clarita. Lo primero que hay que hacer es
"debayerizarla", también tengo código para eso.

Y otra cosa, en el proyecto hay un miniplanteamiento de una clase de tipo
FloatImage, aunque sería más lento, si lo que se quiere es guardar la imagen
en 16bits, se puede utilizar como "trampolín" al FreeImage. Es más lento
porque el buffer de FreeImage es más óptimo, pero en ese formato (el de
FloatImage) tengo diseñados algunos filtros: estadísticos
(mediana/media/stddev) histogramas, curvas, rotaciones, remuestreos,
desenfoques, unsharpmask, DDP,... aunque se puede utilizar FreeImage
directamente (que también también implementa algunos tratamientos básicos en
32 bits) y dejar el proceso a un programa especializado... como debe ser.

En fin, luego sigo con calma.

----- Original Message ----- 
From: "Andres del Pozo Prieto" <and...@gm...>
To: "Lista de correo de desarrollo EQAlign"
<eqa...@li...>
Sent: Thursday, October 04, 2007 6:31 PM
Subject: Re: [Eqalign-devel] Me está dando guerra la QHY


Francisco José wrote:
> Pues eso, hartito me tiene... os planteo otra duda, a ver, tengo este
> código:
>
> // El buffer será de 2621440 bytes (16 bits por pixel,
>                 // la cámara tiene 1310720 pixels)
>                 PixelFormat format =  PixelFormat.Format16bppGrayScale;
>                 System.Drawing.Bitmap bmp = new
> System.Drawing.Bitmap(1280, 1024, format);
>                 System.Drawing.Imaging.BitmapData bmpData =
> bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width,
> bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, format);
>                 GETBUFFER(bmpData.Scan0,1310720);
>                 bmp.UnlockBits(bmpData);
>
> Entiendo que en bmpData.Scan0 tengo el comienzo de la imagen RAW ¿y
> ahora qué he de realizar para obtener la imagen? Si intento guardar o
> fijarla a un control PictureBox me dice que el argumento es inválido
> en una excepción en tiempo de ejecución, por ejemplo:
>
>  bmp.Save(@"c:\test.bmp", ImageFormat.Bmp);
Si no recuerdo mal el formato BMP no admite el formato de greyscale de
16bits. Puedes probar si te lo guarda en formato TIFF.

> Ya mareado, y siendo honesto, he localizado en una web este código,
> pero genera imágenes de 32bits RGB, logro guardar la imagen pero
> claro, la cámara es monocromo y a 16:
>
> [DllImport("kernel32.dll")]
>         private static extern uint CopyMemory (IntPtr dest, IntPtr
> Source, int Length);
>
>         private Bitmap Bitmap32FromUnmanagedArray1(IntPtr image, int
> width, int height)
>         {
>             Bitmap bmp = new Bitmap(width, height,
> PixelFormat.Format32bppRgb);
>
>             BitmapData bmData = bmp.LockBits(new Rectangle(0, 0,
> bmp.Width, bmp.Height),
>                 ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
>
>             IntPtr dest = bmData.Scan0;
>             IntPtr source = image;
>             int len = width*4;
>
>             if ( bmData.Stride == len )
>             {
>                 CopyMemory(dest, source, width*height*4);
>             }
>             else
>             {
>                 for( int y = 0; y < bmp.Height; y++ )
>                 {
>                     CopyMemory(dest, source, len);
>
>                     source = new IntPtr(source.ToInt32() + len);
>                     dest = new IntPtr(dest.ToInt32() + bmData.Stride);
>                 }
>             }
>
>
>             bmp.UnlockBits(bmData);
>
>             return bmp;
>         }
>
> Cambiando Format32bppArgb por Format16bppGrayScale me da error de
> acceso a memoria, soy torpe, ¿qué hago mal?
Además de cambiar el pixelformat a 16bits tienes que cambiar los dos
factores 4 por 2!!!

Saludos,

Andrés.

-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems?  Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/
_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel


-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems?  Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/
_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel 

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[Antonio F. <ant...@ya...>]

Este tema del GDI es muy interesante!!, lo siento chicos, me incorporo al 
hilo en un par de horas, ahora sólo tuve tiempo de leer el correo pero es la 
hora del baño-cena-cuento-cama de Matías, el ritual de todos los días :-))

Sólo una cosa, hasta donde pude averiguar el GDI no permite guardar TIFF 16, 
en su día me hice con las librerías de FreeImage para eso; pero si, por 
ahora, lo que queremos es captarla como cámara guía, lo que tenemos que 
hacer es convertir el formato de profundidad de bit 16 a profundidad 8.

Otra cosa más, la Luna es en color ¿no?, al recogerlo en un formato de 
16bits grayscale, como debe ser, lo que vas a tener es una imagen RAW como 
dices, con la matriz de bayer bien clarita. Lo primero que hay que hacer es 
"debayerizarla", también tengo código para eso.

Y otra cosa, en el proyecto hay un miniplanteamiento de una clase de tipo 
FloatImage, aunque sería más lento, si lo que se quiere es guardar la imagen 
en 16bits, se puede utilizar como "trampolín" al FreeImage. Es más lento 
porque el buffer de FreeImage es más óptimo, pero en ese formato (el de 
FloatImage) tengo diseñados algunos filtros: estadísticos 
(mediana/media/stddev) histogramas, curvas, rotaciones, remuestreos, 
desenfoques, unsharpmask, DDP,... aunque se puede utilizar FreeImage 
directamente (que también también implementa algunos tratamientos básicos en 
32 bits) y dejar el proceso a un programa especializado... como debe ser.

En fin, luego sigo con calma.

----- Original Message ----- 
From: "Andres del Pozo Prieto" <and...@gm...>
To: "Lista de correo de desarrollo EQAlign" 
<eqa...@li...>
Sent: Thursday, October 04, 2007 6:31 PM
Subject: Re: [Eqalign-devel] Me está dando guerra la QHY


Francisco José wrote:
> Pues eso, hartito me tiene... os planteo otra duda, a ver, tengo este
> código:
>
> // El buffer será de 2621440 bytes (16 bits por pixel,
>                 // la cámara tiene 1310720 pixels)
>                 PixelFormat format =  PixelFormat.Format16bppGrayScale;
>                 System.Drawing.Bitmap bmp = new
> System.Drawing.Bitmap(1280, 1024, format);
>                 System.Drawing.Imaging.BitmapData bmpData =
> bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width,
> bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, format);
>                 GETBUFFER(bmpData.Scan0,1310720);
>                 bmp.UnlockBits(bmpData);
>
> Entiendo que en bmpData.Scan0 tengo el comienzo de la imagen RAW ¿y
> ahora qué he de realizar para obtener la imagen? Si intento guardar o
> fijarla a un control PictureBox me dice que el argumento es inválido
> en una excepción en tiempo de ejecución, por ejemplo:
>
>  bmp.Save(@"c:\test.bmp", ImageFormat.Bmp);
Si no recuerdo mal el formato BMP no admite el formato de greyscale de
16bits. Puedes probar si te lo guarda en formato TIFF.

> Ya mareado, y siendo honesto, he localizado en una web este código,
> pero genera imágenes de 32bits RGB, logro guardar la imagen pero
> claro, la cámara es monocromo y a 16:
>
> [DllImport("kernel32.dll")]
>         private static extern uint CopyMemory (IntPtr dest, IntPtr
> Source, int Length);
>
>         private Bitmap Bitmap32FromUnmanagedArray1(IntPtr image, int
> width, int height)
>         {
>             Bitmap bmp = new Bitmap(width, height,
> PixelFormat.Format32bppRgb);
>
>             BitmapData bmData = bmp.LockBits(new Rectangle(0, 0,
> bmp.Width, bmp.Height),
>                 ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
>
>             IntPtr dest = bmData.Scan0;
>             IntPtr source = image;
>             int len = width*4;
>
>             if ( bmData.Stride == len )
>             {
>                 CopyMemory(dest, source, width*height*4);
>             }
>             else
>             {
>                 for( int y = 0; y < bmp.Height; y++ )
>                 {
>                     CopyMemory(dest, source, len);
>
>                     source = new IntPtr(source.ToInt32() + len);
>                     dest = new IntPtr(dest.ToInt32() + bmData.Stride);
>                 }
>             }
>
>
>             bmp.UnlockBits(bmData);
>
>             return bmp;
>         }
>
> Cambiando Format32bppArgb por Format16bppGrayScale me da error de
> acceso a memoria, soy torpe, ¿qué hago mal?
Además de cambiar el pixelformat a 16bits tienes que cambiar los dos
factores 4 por 2!!!

Saludos,

Andrés.

-------------------------------------------------------------------------
This SF.net email is sponsored by: Splunk Inc.
Still grepping through log files to find problems?  Stop.
Now Search log events and configuration files using AJAX and a browser.
Download your FREE copy of Splunk now >> http://get.splunk.com/
_______________________________________________
Eqalign-devel mailing list
Eqa...@li...
https://lists.sourceforge.net/lists/listinfo/eqalign-devel 

Re: [Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[Andres d. P. P. <and...@gm...>]

Francisco José wrote:
> Pues eso, hartito me tiene... os planteo otra duda, a ver, tengo este 
> código:
>
> // El buffer será de 2621440 bytes (16 bits por pixel,
>                 // la cámara tiene 1310720 pixels)
>                 PixelFormat format =  PixelFormat.Format16bppGrayScale;
>                 System.Drawing.Bitmap bmp = new 
> System.Drawing.Bitmap(1280, 1024, format);
>                 System.Drawing.Imaging.BitmapData bmpData = 
> bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, 
> bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, format);
>                 GETBUFFER(bmpData.Scan0,1310720);
>                 bmp.UnlockBits(bmpData);
>
> Entiendo que en bmpData.Scan0 tengo el comienzo de la imagen RAW ¿y 
> ahora qué he de realizar para obtener la imagen? Si intento guardar o 
> fijarla a un control PictureBox me dice que el argumento es inválido 
> en una excepción en tiempo de ejecución, por ejemplo:
>
>  bmp.Save(@"c:\test.bmp", ImageFormat.Bmp);
Si no recuerdo mal el formato BMP no admite el formato de greyscale de 
16bits. Puedes probar si te lo guarda en formato TIFF.

> Ya mareado, y siendo honesto, he localizado en una web este código, 
> pero genera imágenes de 32bits RGB, logro guardar la imagen pero 
> claro, la cámara es monocromo y a 16:
>
> [DllImport("kernel32.dll")]
>         private static extern uint CopyMemory (IntPtr dest, IntPtr 
> Source, int Length);
>
>         private Bitmap Bitmap32FromUnmanagedArray1(IntPtr image, int 
> width, int height)
>         {
>             Bitmap bmp = new Bitmap(width, height, 
> PixelFormat.Format32bppRgb);
>
>             BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, 
> bmp.Width, bmp.Height),
>                 ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
>
>             IntPtr dest = bmData.Scan0;
>             IntPtr source = image;
>             int len = width*4;
>
>             if ( bmData.Stride == len )
>             {
>                 CopyMemory(dest, source, width*height*4);
>             }
>             else
>             {
>                 for( int y = 0; y < bmp.Height; y++ )
>                 {
>                     CopyMemory(dest, source, len);
>
>                     source = new IntPtr(source.ToInt32() + len);
>                     dest = new IntPtr(dest.ToInt32() + bmData.Stride);
>                 }
>             }
>
>           
>             bmp.UnlockBits(bmData);
>
>             return bmp;
>         }
>
> Cambiando Format32bppArgb por Format16bppGrayScale me da error de 
> acceso a memoria, soy torpe, ¿qué hago mal?
Además de cambiar el pixelformat a 16bits tienes que cambiar los dos 
factores 4 por 2!!!

Saludos,

Andrés.

[Eqalign-devel] =?iso-8859-1?q?Me_est=E1_dando_guerra_la_QHY?=

[<is...@ya...>]

Pues eso, hartito me tiene... os planteo otra duda, a ver, tengo este código:

// El buffer será de 2621440 bytes (16 bits por pixel, 
                // la cámara tiene 1310720 pixels)
                PixelFormat format =  PixelFormat.Format16bppGrayScale;
                System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(1280, 1024, format);
                System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, format);
                GETBUFFER(bmpData.Scan0,1310720);
                bmp.UnlockBits(bmpData);

Entiendo que en bmpData.Scan0 tengo el comienzo de la imagen RAW ¿y ahora qué he de realizar para obtener la imagen? Si intento guardar o fijarla a un control PictureBox me dice que el argumento es inválido en una excepción en tiempo de ejecución, por ejemplo:

 bmp.Save(@"c:\test.bmp", ImageFormat.Bmp);

Ya mareado, y siendo honesto, he localizado en una web este código, pero genera imágenes de 32bits RGB, logro guardar la imagen pero claro, la cámara es monocromo y a 16:

[DllImport("kernel32.dll")]
        private static extern uint CopyMemory (IntPtr dest, IntPtr Source, int Length);

        private Bitmap Bitmap32FromUnmanagedArray1(IntPtr image, int width, int height)
        {
            Bitmap bmp = new Bitmap(width, height, PixelFormat.Format32bppRgb);

            BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);

            IntPtr dest = bmData.Scan0;
            IntPtr source = image;
            int len = width*4;

            if ( bmData.Stride == len )
            {
                CopyMemory(dest, source, width*height*4);
            }
            else
            {
                for( int y = 0; y < bmp.Height; y++ )
                {
                    CopyMemory(dest, source, len);

                    source = new IntPtr(source.ToInt32() + len);
                    dest = new IntPtr(dest.ToInt32() + bmData.Stride);
                }
            }

           
            bmp.UnlockBits(bmData);

            return bmp;
        }

Cambiando Format32bppArgb por Format16bppGrayScale me da error de acceso a memoria, soy torpe, ¿qué hago mal?

Un saludo!

       
---------------------------------

Sé un Mejor Amante del Cine
¿Quieres saber cómo? ¡Deja que otras personas te ayuden!.

Re: [Eqalign-devel] Beta

[<is...@ya...>]

Muchísimas gracias Andrés, esta tarde le meteré mano al código, a ver si soluciono el problema.

Un saludo!

--- Andres del Pozo Prieto <and...@gm...> escribió:

> Francisco José wrote:
> > Por pedir que no quede!! jejee
> >
> > Bueno, antes de nada te planteo una duda que me está volviendo loco, a 
> > ver si me puedes echar una mano tu que estás más puesto en C#; verás, 
> > al realizar una exposición la cámara almacena la imagen en un buffer 
> > interno, la función que se encarga de esto, en C++ es:
> >   EXPORT void _stdcall GETBUFFER(void *x, DWORD s);
> >
> > Lo que traducida a C# se me quedaría así:
> >  [DllImport("CMOSDLL.DLL")]
> >         private static extern void GETBUFFER(IntPtr x, uint s);
> >
> > Esta función necesita el buffer y los pixels que se desean obtener.
> >
> > [...]
> En el programa que me hice para controlar la reflex tuve un problema 
> parecido. Lo solucioné haciendo lo siguiente:
> * Crear un Bitmap en el formato (pixelformat) en el que la DLL te va a 
> devolver los datos
> * Obtener un objeto BitmapData para acceder a los datos del bitmap 
> utilizando Bitmap.LockBits()
> * La propiedad BitmapData.Scan0 te da un puntero a los datos que le 
> puedes pasar a la DLL
> 
> Sería esto:
> 
>     PixelFormat format =  PixelFormat.Format16bppGrayScale;
>     System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(width, height, 
> format);
> 
>     System.Drawing.Imaging.BitmapData bmpData =
>           bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, 
> bmp.Height),
>                        System.Drawing.Imaging.ImageLockMode.ReadWrite,
>                        format);
> 
>     GETBUFFER(bmpData.Scan0,1310720);
> 
>     bmp.UnlockBits();
> 
> Espero que te sirva.
> 
> Saludos,
> 
> Andrés.
> 
> -------------------------------------------------------------------------
> This SF.net email is sponsored by: Splunk Inc.
> Still grepping through log files to find problems?  Stop.
> Now Search log events and configuration files using AJAX and a browser.
> Download your FREE copy of Splunk now >> http://get.splunk.com/
> _______________________________________________
> Eqalign-devel mailing list
> Eqa...@li...
> https://lists.sourceforge.net/lists/listinfo/eqalign-devel
> 



       
____________________________________________________________________________________
Sé un Mejor Amante del Cine                         
¿Quieres saber cómo? ¡Deja que otras personas te ayuden!
http://advision.webevents.yahoo.com/reto/entretenimiento.html

Re: [Eqalign-devel] Beta

[Andres d. P. P. <and...@gm...>]

Francisco José wrote:
> Por pedir que no quede!! jejee
>
> Bueno, antes de nada te planteo una duda que me está volviendo loco, a 
> ver si me puedes echar una mano tu que estás más puesto en C#; verás, 
> al realizar una exposición la cámara almacena la imagen en un buffer 
> interno, la función que se encarga de esto, en C++ es:
>   EXPORT void _stdcall GETBUFFER(void *x, DWORD s);
>
> Lo que traducida a C# se me quedaría así:
>  [DllImport("CMOSDLL.DLL")]
>         private static extern void GETBUFFER(IntPtr x, uint s);
>
> Esta función necesita el buffer y los pixels que se desean obtener.
>
> [...]
En el programa que me hice para controlar la reflex tuve un problema 
parecido. Lo solucioné haciendo lo siguiente:
* Crear un Bitmap en el formato (pixelformat) en el que la DLL te va a 
devolver los datos
* Obtener un objeto BitmapData para acceder a los datos del bitmap 
utilizando Bitmap.LockBits()
* La propiedad BitmapData.Scan0 te da un puntero a los datos que le 
puedes pasar a la DLL

Sería esto:

    PixelFormat format =  PixelFormat.Format16bppGrayScale;
    System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(width, height, 
format);

    System.Drawing.Imaging.BitmapData bmpData =
          bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, 
bmp.Height),
                       System.Drawing.Imaging.ImageLockMode.ReadWrite,
                       format);

    GETBUFFER(bmpData.Scan0,1310720);

    bmp.UnlockBits();

Espero que te sirva.

Saludos,

Andrés.