image prise et enregistrer directement l'image à l'aide de PC edsdk 2.8

Question

Je suis nouveau à la EDSDK 2.8

En ce moment, mon programme peut prendre des photos. Cependant, lorsqu'une photo est prise, cette image est temporairement stockée dans un tampon dans l'appareil photo Canon. Je voudrais savoir comment enregistrer le répertoire sur le PC?

Quelqu'un a-t-il des idées? Ou un exemple de code dans C# ou vb.net?

Answer 1

Voici ce que je l'ai fait:

D'abord, vous devez vous inscrire à l'événement de rappel lorsqu'un objet est créé (par exemple, une image). Je l'ai fait dans une méthode RegisterEvents que j'ai créé:

// Register OBJECT events 
edsObjectEventHandler = new EDSDK.EdsObjectEventHandler(objectEventHandler); 
error = EDSDK.EdsSetObjectEventHandler(this.CameraDevice, 
       EDSDK.ObjectEvent_All, edsObjectEventHandler, IntPtr.Zero); 
if (EDSDK.EDS_ERR_OK != error) 
{ 
    throw new CameraEventRegistrationException("Unable to 
     register object events with the camera!", error); 
} 

Le objectEventHandler est la méthode qui sera appelée quand une image est créée.

La méthode doit être conforme à l'interface dictée par l'API. Voici un exemple d'implémentation de cette méthode:

/// <summary> 
/// Registered callback function for recieving object events 
/// </summary> 
/// <param name="inEvent">Indicate the event type supplemented.</param> 
/// <param name="inRef">Returns a reference to objects created by the event.</param> 
/// <param name="inContext">Passes inContext without modification</param> 
/// <returns>Status 0 (OK)</returns> 
private uint objectEventHandler(uint inEvent, IntPtr inRef, IntPtr inContext) 
{ 
    switch (inEvent) 
    { 
     case EDSDK.ObjectEvent_DirItemCreated: 
      this.invokeNewItemCreatedEvent(new NewItemCreatedEventArgs(getCapturedItem(inRef))); 
      Console.WriteLine("Directory Item Created"); 
      break; 
     case EDSDK.ObjectEvent_DirItemRequestTransfer: 
      Console.WriteLine("Directory Item Requested Transfer"); 
      break; 
     default: 
      Console.WriteLine(String.Format("ObjectEventHandler: event {0}, ref {1}", inEvent.ToString("X"), inRef.ToString())); 
      break; 
    } 

    return 0x0; 
} 

Dans cet exemple, je me retourne et Spawn mon propre événement, qui a la référence à l'objet de flux. Ceci est géré par le code suivant:

 /// <summary> 
     /// Gets a photo or video clip from the camera 
     /// </summary> 
     /// <param name="directoryItem">Reference to the item that the camera captured.</param> 
     /// <returns></returns> 
     private CapturedItem getCapturedItem(IntPtr directoryItem) 
     { 
      uint err = EDSDK.EDS_ERR_OK; 
      IntPtr stream = IntPtr.Zero; 

      EDSDK.EdsDirectoryItemInfo dirItemInfo; 

      err = EDSDK.EdsGetDirectoryItemInfo(directoryItem, out dirItemInfo); 

      if (err != EDSDK.EDS_ERR_OK) 
      { 
       throw new CameraException("Unable to get captured item info!", err); 
      } 

      // Fill the stream with the resulting image 
      if (err == EDSDK.EDS_ERR_OK) 
      { 
       err = EDSDK.EdsCreateMemoryStream((uint)dirItemInfo.Size, out stream); 
      } 

      // Copy the stream to a byte[] and 
      if (err == EDSDK.EDS_ERR_OK) 
      { 
       err = EDSDK.EdsDownload(directoryItem, (uint)dirItemInfo.Size, stream); 
      } 

      // Create the returned item 
      CapturedItem item = new CapturedItem(); 

      if (err == EDSDK.EDS_ERR_OK) 
      { 
       IntPtr imageRef = IntPtr.Zero; 

       err = EDSDK.EdsCreateImageRef(stream, out imageRef); 

       if (err == EDSDK.EDS_ERR_OK) 
       { 
        EDSDK.EdsImageInfo info; 
        err = EDSDK.EdsGetImageInfo(imageRef, EDSDK.EdsImageSource.FullView, out info); 

        if (err == EDSDK.EDS_ERR_OK) 
        { 
         item.Dimensions = new com.waynehartman.util.graphics.Dimension((int)info.Width, (int)info.Height); 

         EDSDK.EdsRelease(imageRef); 
        } 
       } 
      } 

      if (err == EDSDK.EDS_ERR_OK) 
      { 
       byte[] buffer = new byte[(int)dirItemInfo.Size]; 

       GCHandle gcHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned); 

       IntPtr address = gcHandle.AddrOfPinnedObject(); 

       IntPtr streamPtr = IntPtr.Zero; 

       err = EDSDK.EdsGetPointer(stream, out streamPtr); 

       if (err != EDSDK.EDS_ERR_OK) 
       { 
        throw new CameraDownloadException("Unable to get resultant image.", err); 
       } 

       try 
       { 
        Marshal.Copy(streamPtr, buffer, 0, (int)dirItemInfo.Size); 

        item.Image = buffer; 
        item.Name = dirItemInfo.szFileName; 
        item.Size = (long)dirItemInfo.Size; 
        item.IsFolder = Convert.ToBoolean(dirItemInfo.isFolder); 

        return item; 
       } 
       catch (AccessViolationException ave) 
       { 
        throw new CameraDownloadException("Error copying unmanaged stream to managed byte[].", ave); 
       } 
       finally 
       { 
        gcHandle.Free(); 
        EDSDK.EdsRelease(stream); 
        EDSDK.EdsRelease(streamPtr); 
       } 
      } 
      else 
      { 
       throw new CameraDownloadException("Unable to get resultant image.", err); 
      } 
     } 

Answer 2

Je suis en train de faire la même chose dans ce que j'ai pas de carte mémoire dans l'appareil photo et que vous souhaitez transférer l'image sur l'ordinateur hôte après la commande image prise est envoyée. Voici ce qui a fonctionné pour moi pour appeler le rappel ObjectEventHandler lorsqu'aucune carte mémoire n'est installée dans le Canon EOS50D.

EdsUInt32 setsaveto = kEdsSaveTo_Both; 
err = EdsSetPropertyData(camera, kEdsPropID_SaveTo, 0, sizeof(setsaveto), &setsaveto); 

Voila, le rappel est appelé et je peux ensuite passer à faire la fonction getCapturedItem() que Wayne a affiché dans le précédent post.