src/Plugin.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2010 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

/*
 SMI RED eye tracking system library based on iView X SDK
 First version : june 2011
 Author : Aymeric Suteau
*/

// Include Header File
#include "Plugin.h"

cbmachine ww;
HWND HScol = NULL;      

int OBJSMISCOL;

//===== CB Connected ===
int SCOL_SMI_CONNECTED_CB          = 0;
int SMI_CONNECTED_CB;

//===== CB Disconnected ===
int SCOL_SMI_DISCONNECTED_CB       = 1;
int SMI_DISCONNECTED_CB;

//===== CB Calibration done ===
int SCOL_SMI_CALIBRATION_DONE_CB   = 2;
int SMI_CALIBRATION_DONE_CB;

//===== CB New fixation data ===
int SCOL_SMI_NEW_FIXATION_CB       = 3;
int SMI_NEW_FIXATION_CB;

//===== CB New sample data ===
int SCOL_SMI_NEW_SAMPLE_CB         = 4;
int SMI_NEW_SAMPLE_CB;



int destroySmiObj(mmachine m, int handsys, int eyeTrackingTab) 
{
        // Read the first element of a TAB element (table of objects)
        EyeTracking* EyeTrackingObj = (EyeTracking*) MMfetch(m, MTOP(eyeTrackingTab), 0);

        // Safely dispose of "EyeTrackingObj" pointer
        SAFE_DELETE(EyeTrackingObj);

        // Write the first element of a TAB element
        MMstore(m, MTOP(eyeTrackingTab), 0, 0);

        // Display debug message
        MMechostr(0, "EyeTrackingObj destroyed.\n");
        return 0;
}


int _OpenSmiDevice(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(0,"_OpenSmiDevice\n");
        #endif

        // Declare local variables
        int k = 0;

  // Retrieve stack parameters : [S I S I]
  // NOTE: The first parameter to pull from the stack is the last one to have been pushed
  int iReceiverPort = MMpull(m);
  int iReceiverIp = MMpull(m);
  int iSenderPort = MMpull(m);
  int iSenderIp = MMpull(m);
 
  // Convert sender IP from magma to char*
  char* senderIp = (char*) MMstartstr(m, MTOP(iSenderIp));

  // Convert sender port from Magma to Integer
  int senderPort = 4444;
        if (iSenderPort != NIL)
                senderPort = MTOI(iSenderPort);

  // Convert receiver IP from magma to char*
  char* receiverIp = (char*) MMstartstr(m, MTOP(iReceiverIp));

  // Convert receiver port from Magma to Integer
  int receiverPort = 5555;
  if (iReceiverPort != NIL)
                receiverPort = MTOI(iReceiverPort);

        // Create EyeTracking instance
        EyeTracking* eyeTracking = new EyeTracking();
  MMechostr(0, "_OpenSmiDevice ...new SMI RED EyeTracking instance created !\n");

        // TODO: Open remote EyeTracking system
  if (!eyeTracking->Connect(senderIp, senderPort, receiverIp, receiverPort))
  {
                MMechostr(0, "_OpenSmiDevice ...initialization failed\n");
                SAFE_DELETE(eyeTracking);
                MMset(m, 0, NIL);
                return 0;
        }
 
        // Allocate a block in the stack for a table of EyeTracking objects
        int eyeTrackingTab = MMmalloc(m, 1, TYPETAB);
        if (eyeTrackingTab == NIL)
  {
                MMechostr(0, "_OpenSmiDevice ...MMmalloc failed\n");
                SAFE_DELETE(eyeTracking); 
                MMset(m, 0, NIL);
    return MERRMEM;
        }
        MMechostr(0, "_OpenSmiDevice ...MMmalloc successful\n");

        // Push the TAB EyeTracking object into the stack
        MMstore(m, eyeTrackingTab, 0, (int)eyeTracking);
        MMpush(m, PTOM(eyeTrackingTab));

        // Create a new SMI RED EyeTracking object
        k = OBJcreate(m, OBJSMISCOL, (int)eyeTracking, NULL, NULL);
        MMechostr(0, "_OpenSmiDevice ...object creation successful\n");

        #ifdef  _SCOL_DEBUG_
                MMechostr(0,"ok\n");
        #endif

        // Return EyeTracking object
        return k;
}


int _CloseSmiDevice(mmachine m)
{
        #ifdef  _SCOL_DEBUG_
                MMechostr(0,"_CloseSmiDevice\n");
  #endif

        // Get the table of EyeTracking objects into the stack (without pulling it)
        int eyeTrackingTab = MMget(m, 0);
  MMechostr(0, "_CloseSmiDevice\n");
        if (eyeTrackingTab == NIL)
  {
                MMechostr(0, "_CloseSmiDevice ...ObjSmi NIL\n");
                MMset(m, 0, NIL);
                return 0;
        }

        // Destroy EyeTracking object according to its type and magma object
  OBJdelTM(m, OBJSMISCOL, eyeTrackingTab);

        // Reinitialize the stack
        MMset(m, 0, ITOM(0));

        #ifdef  _SCOL_DEBUG_
                MMechostr(0,"ok\n");
        #endif

        return 0;
}


int _CBSmiConnected(mmachine m)
{
  MMechostr(0, "_CBSmiConnected ...adding reflex\n");
        return OBJaddreflex(m, OBJSMISCOL, SCOL_SMI_CONNECTED_CB);
}

int getSmiConnectedCb(mmachine m, HWND h, unsigned msg, UINT id, LONG param, int *ret)
{
        int k = 0;
        EyeTracking* EyeTrackingObj = (EyeTracking*) id;
        
        // OBJbeginreflex(mmachine, objecttype, objectptr, cbtype)
        if (OBJbeginreflex(m, OBJSMISCOL, (int)EyeTrackingObj, SCOL_SMI_CONNECTED_CB))
  {
    MMechostr(0, "getSmiConnectedCb -> OBJbeginreflex failed.\n");
                return 0;
  }
        return (OBJcallreflex(m, 0));
}


int _CBSmiDisconnected(mmachine m)
{
  MMechostr(0, "_CBSmiDisconnected ...adding reflex\n");
        return OBJaddreflex(m, OBJSMISCOL, SCOL_SMI_DISCONNECTED_CB);
}

int getSmiDisconnectedCb(mmachine m, HWND h, unsigned msg, UINT id, LONG param, int *ret)
{
        int k = 0;
        EyeTracking* EyeTrackingObj = (EyeTracking*) id;

        // OBJbeginreflex(mmachine, objecttype, objectptr, cbtype)
        if (OBJbeginreflex(m, OBJSMISCOL, (int)EyeTrackingObj, SCOL_SMI_DISCONNECTED_CB))
  {
    MMechostr(0, "getSmiDisconnectedCb -> OBJbeginreflex failed.\n");
                return 0;
  }
        return (OBJcallreflex(m, 0));
}


int _CBSmiCalibrationDone(mmachine m)
{
  MMechostr(0, "_CBSmiCalibrationDone ...adding reflex\n");
        return OBJaddreflex(m, OBJSMISCOL, SCOL_SMI_CALIBRATION_DONE_CB);
}

int getSmiCalibrationDoneCb(mmachine m, HWND h, unsigned msg, UINT id, LONG param, int *ret)
{
        int k = 0;
        EyeTracking* EyeTrackingObj = (EyeTracking*) id;

        // OBJbeginreflex(mmachine, objecttype, objectptr, cbtype)
        if (OBJbeginreflex(m, OBJSMISCOL, (int)EyeTrackingObj, SCOL_SMI_CALIBRATION_DONE_CB))
  {
    MMechostr(0, "getSmiCalibrationDoneCb -> OBJbeginreflex failed.\n");
                return 0;
  }
        return (OBJcallreflex(m, 0));
}


int _CBSmiNewFixation(mmachine m)
{
  MMechostr(0, "_CBSmiNewFixation ...adding reflex\n");
        return OBJaddreflex(m, OBJSMISCOL, SCOL_SMI_NEW_FIXATION_CB);
}

int getSmiNewFixationCb(mmachine m, HWND h, unsigned msg, UINT id, LONG param, int *ret)
{
        int k = 0;
  FixationData* FixationDataObj = (FixationData*) param;
        EyeTracking* EyeTrackingObj = (EyeTracking*) id;
  float fDuration = FixationDataObj->duration;
  int iPosX = FixationDataObj->posX;
  int iPosY = FixationDataObj->posY;

        // OBJbeginreflex(mmachine, objecttype, objectptr, cbtype)
        if (OBJbeginreflex(m, OBJSMISCOL, (int)EyeTrackingObj, SCOL_SMI_NEW_FIXATION_CB))
  {
    MMechostr(0, "getSmiNewFixationCb -> OBJbeginreflex failed.\n");
                return 0;
  }

  // Push fixation data into the stack
        MMpush(m, FTOM(fDuration));
  MMpush(m, ITOM(iPosX));
  MMpush(m, ITOM(iPosY));
        return (OBJcallreflex(m, 3));
}


int _CBSmiNewSample(mmachine m)
{
  MMechostr(0, "_CBSmiNewSample ...adding reflex\n");
        return OBJaddreflex(m, OBJSMISCOL, SCOL_SMI_NEW_SAMPLE_CB);
}

int getSmiNewSampleCb(mmachine m, HWND h, unsigned msg, UINT id, LONG param, int *ret)
{
        int k = 0;
  SampleData* SampleDataObj = (SampleData*) param;
        EyeTracking* EyeTrackingObj = (EyeTracking*) id;
  float fLeftDiam = SampleDataObj->leftPupilDiameter;
  float fRightDiam = SampleDataObj->rightPupilDiameter;
  int iLeftGazeX = SampleDataObj->leftGazeX;
  int iRightGazeX = SampleDataObj->rightGazeX;
  int iLeftGazeY = SampleDataObj->leftGazeY;
  int iRightGazeY = SampleDataObj->rightGazeY;

        // OBJbeginreflex(mmachine, objecttype, objectptr, cbtype)
        if (OBJbeginreflex(m, OBJSMISCOL, (int)EyeTrackingObj, SCOL_SMI_NEW_FIXATION_CB))
  {
    MMechostr(0, "getSmiNewFixationCb -> OBJbeginreflex failed.\n");
                return 0;
  }

  // Push sample data into the stack
  int tupleLeftEye = MMmalloc(m, 3, TYPETAB);
        if (tupleLeftEye == NIL) 
  {     
    MMset(m, 0, NIL);           
    return MERRMEM;     
  }
  MMstore(m, tupleLeftEye, 0, FTOM(fLeftDiam));
        MMstore(m, tupleLeftEye, 1, ITOM(iLeftGazeX));
  MMstore(m, tupleLeftEye, 2, ITOM(iLeftGazeY));
  MMpush(m, PTOM(tupleLeftEye));

  int tupleRightEye = MMmalloc(m, 3, TYPETAB);
        if (tupleRightEye == NIL) 
  {     
    MMset(m, 0, NIL);           
    return MERRMEM;     
  }
  MMstore(m, tupleRightEye, 0, FTOM(fRightDiam));
        MMstore(m, tupleRightEye, 1, ITOM(iRightGazeX));
  MMstore(m, tupleRightEye, 2, ITOM(iRightGazeY));
  MMpush(m, PTOM(tupleRightEye));

        return (OBJcallreflex(m, 2));
}


int _StartCalibration(mmachine m)
{
        #ifdef _SCOL_DEBUG_
                MMechostr(0,"_StartCalibration\n");
        #endif

  // Retrieve stack parameters : [I I I I I I I I]
  // NOTE: The first parameter to pull from the stack is the last one to have been pushed
  int iTargetSize = MMpull(m);
  int iTargetShape = MMpull(m);
  int iBackgroundBrightness = MMpull(m);
  int iForegroundBrightness = MMpull(m);
  int iSpeed = MMpull(m);
  int iDisplayDevice = MMpull(m);
  int iValidation = MMpull(m);
  int iNbPoints = MMpull(m);

  // Convert all stack parameters from Magma to Integer
  int nbPoints = 5;
        if (iNbPoints != NIL)
                nbPoints = MTOI(iNbPoints);

  int validation = 1;
  if (iValidation != NIL)
                validation = MTOI(iValidation);

  int displayDevice = 0;
  if (iDisplayDevice != NIL)
                displayDevice = MTOI(iDisplayDevice);

  int speed = 0;
  if (iSpeed != NIL)
                speed = MTOI(iSpeed);

  int foregroundBrightness = 20;
  if (iForegroundBrightness != NIL)
                foregroundBrightness = MTOI(iForegroundBrightness);

  int backgroundBrightness = 239;
  if (iBackgroundBrightness != NIL)
                backgroundBrightness = MTOI(iBackgroundBrightness);

  int targetShape = 1;
  if (iTargetShape != NIL)
                targetShape = MTOI(iTargetShape) + 1;
  
  int targetSize = 10;
  if (iTargetSize != NIL)
                targetSize = MTOI(iTargetSize);

  // Get the table of glove objects into the stack (without pulling it)
        int smiTab = MMget(m, 0);
  MMechostr(0, "_StartCalibration\n");
        if (smiTab == NIL) 
  {
                MMechostr(0, "_StartCalibration ...ObjSmi NIL\n");
                MMset(m, 0, -1);
                return 0;
        }

  // Read the first element of a TAB element (table of objects)
        EyeTracking* SmiObj = (EyeTracking*) MMfetch(m, MTOP(smiTab), 0);
        if (SmiObj == NULL) 
  {
                // Write the first element in the stack, without pulling it
                MMset(m, 0, NIL); 
                return 0; 
        }

  // Set up the calibration for SMI RED system
  SmiObj->SetCalibration(nbPoints,                    // 5-point calibration method
                         1,                           // Visualization by SDK
                         displayDevice,               // Primary device for display
                         speed,                       // Low validation speed
                         1,                           // Point auto-acceptance
                         foregroundBrightness,        // Target brightness
                         backgroundBrightness,        // Background brightness
                         targetShape,                 // Calibration target shape = CIRCLE1
                         targetSize,                  // Default target size is 10 pixels
                         "../resource/cursor1.bmp");  // Target shape filename

  // Start the calibration process
  SmiObj->Calibrate(validation);
  
  MMset(m, 0, ITOM(0));
  
  #ifdef _SCOL_DEBUG_
                MMechostr(0,"ok\n");
        #endif

  return 0;
}


int _ShowEyes(mmachine m)
{
        #ifdef _SCOL_DEBUG_
                MMechostr(0,"_ShowEyes\n");
        #endif

  // Retrieve stack parameter
  int iShowEyes = MMpull(m);

  // Convert stack parameter from Magma to Integer
  int showEyes = 1;
        if (iShowEyes != NIL)
                showEyes = MTOI(iShowEyes);

  // Get the table of glove objects into the stack (without pulling it)
        int smiTab = MMget(m, 0);
  MMechostr(0, "_ShowEyes\n");
        if (smiTab == NIL) 
  {
                MMechostr(0, "_ShowEyes ...ObjSmi NIL\n");
                MMset(m, 0, -1);
                return 0;
        }

        EyeTracking* SmiObj = (EyeTracking*) MMfetch(m, MTOP(smiTab), 0);
        if (SmiObj == NULL) 
  {
                // Write the first element in the stack, without pulling it
                MMset(m, 0, NIL); 
                return 0; 
        }

  // Check if eye tracking window must be displayed
  if (showEyes == 1)
    SmiObj->ShowTrackingWindow();
  
  MMset(m, 0, ITOM(0));
  
  #ifdef _SCOL_DEBUG_
                MMechostr(0,"ok\n");
        #endif

  return 0;
}




#define NbTplPKG 10


char *TplName[NbTplPKG] =
{
        "ObjSmi",
  "_OpenSmiDevice",
        "_CloseSmiDevice",
  "_CBSmiConnected",
  "_CBSmiDisconnected",
  "_CBSmiCalibrationDone",
  "_CBSmiNewFixation",
  "_CBSmiNewSample",
  "_StartCalibration",
  "_ShowEyes"
};


int (*TplFunc[NbTplPKG])(mmachine m)=
{
        NULL,                                                                                                                                           // ObjSmi
  _OpenSmiDevice,                                                                                                       // _OpenSmiDevice
        _CloseSmiDevice,                                                                                                // _CloseSmiDevice
  _CBSmiConnected,                        // _CBSmiConnected
  _CBSmiDisconnected,                     // _CBSmiDisconnected
  _CBSmiCalibrationDone,                  // _CBSmiCalibrationDone
  _CBSmiNewFixation,                      // _CBSmiNewFixation
  _CBSmiNewSample,                        // _CBSmiNewSample
  _StartCalibration,                      // _StartCalibration
  _ShowEyes                               // _ShowEyes
};


int TplNArg[NbTplPKG]=
{
        TYPTYPE,                                                                                                                                                // ObjSmi
  5,                                                                                                                                                                    // _OpenSmiDevice
        1,                                                                                                                                                                      // _CloseSmiDevice
  3,                                          // _CBSmiConnected
  3,                                          // _CBSmiDisconnected
  3,                                          // _CBSmiCalibrationDone
  3,                                          // _CBSmiNewFixation
  3,                                          // _CBSmiNewSample
  9,                                          // _StartCalibration
  2                                           // _ShowEyes
};


char* TplType[NbTplPKG]=
{
        NULL,                                                                                                                                                                                         // ObjSmi
  "fun [Chn S I S I] ObjSmi",                                                                                                       // _OpenSmiDevice
        "fun [ObjSmi] I",                                                                                                                           // _CloseSmiDevice
  "fun [ObjSmi fun [ObjSmi u0] u1 u0] ObjSmi",                                    // _CBSmiConnected
  "fun [ObjSmi fun [ObjSmi u0] u1 u0] ObjSmi",                                    // _CBSmiDisconnected
  "fun [ObjSmi fun [ObjSmi u0] u1 u0] ObjSmi",                              // _CBSmiCalibrationDone
  "fun [ObjSmi fun [ObjSmi u0 F I I] u1 u0] ObjSmi",                        // _CBSmiNewFixation
  "fun [ObjSmi fun [ObjSmi u0 [F I I] [F I I]] u1 u0] ObjSmi",              // _CBSmiNewSample
  "fun [ObjSmi I I I I I I I I] I",                                         // _StartCalibration
  "fun [ObjSmi I] I"                                                        // _ShowEyes
};


// Everything inside _cond and _endcond is ignored by doxygen

int LoadSmi(mmachine m) 
{
  // Return variable for PKhardpak function
        int k;

        // Declare a new type of object ("OBJSMISCOL")
        OBJSMISCOL = OBJregister(5, 1, destroySmiObj, "OBJSMISCOL");

  // Get new user events and associate these events with a callback
  SMI_CONNECTED_CB = OBJgetUserEvent();
  OBJdefEvent(SMI_CONNECTED_CB, (int (__cdecl *)(struct Mmachine *, int, unsigned int, int, int, int *))getSmiConnectedCb);

  SMI_CALIBRATION_DONE_CB = OBJgetUserEvent();
  OBJdefEvent(SMI_CALIBRATION_DONE_CB, (int (__cdecl *)(struct Mmachine *, int, unsigned int, int, int, int *))getSmiCalibrationDoneCb);

  SMI_DISCONNECTED_CB = OBJgetUserEvent();
  OBJdefEvent(SMI_DISCONNECTED_CB, (int (__cdecl *)(struct Mmachine *, int, unsigned int, int, int, int *))getSmiDisconnectedCb);

  SMI_NEW_FIXATION_CB = OBJgetUserEvent();
  OBJdefEvent(SMI_NEW_FIXATION_CB, (int (__cdecl *)(struct Mmachine *, int, unsigned int, int, int, int *))getSmiNewFixationCb);

  SMI_NEW_SAMPLE_CB = OBJgetUserEvent();
  OBJdefEvent(SMI_NEW_SAMPLE_CB, (int (__cdecl *)(struct Mmachine *, int, unsigned int, int, int, int *))getSmiNewSampleCb);

        // Load package
        k = PKhardpak(m, "FusionEngine", NbTplPKG, TplName, TplFunc, TplNArg, TplType);
        return k;
}


extern "C" __declspec (dllexport) int ScolLoadPlugin(mmachine m, cbmachine w) 
{
        SCOLinitplugin(w);

        // Get Scol window handle (for message callback)
        HScol = (HWND)SCgetExtra("hscol");      
        LoadSmi(m);
        return 0;
}


extern "C" __declspec (dllexport) int ScolUnloadPlugin() 
{
        return 0;
}