Beispiel #1
0
//
// Request double buffer display mode.
// Register mouse input callback functions
//
int main(int argc, char** argv)
{
   EmoEngineEventHandle hEvent = IEE_EmoEngineEventCreate();
   EmoStateHandle eState = IEE_EmoStateCreate();
   unsigned int userID = -1;
   IEE_EngineConnect();

#ifdef _WIN32
   globalElapsed = GetTickCount();
#endif
#ifdef __linux__
   globalElapsed = ( unsigned long ) GetTickCount();
#endif

   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
   glutInitWindowSize (650, 650); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape); 
   glutIdleFunc(updateDisplay);
   glutMainLoop();
    
   // Clean up
   IEE_EngineDisconnect();
   IEE_EmoStateFree(eState);
   IEE_EmoEngineEventFree(hEvent);	

   return 0;
}
Beispiel #2
0
int main(int argc, char **argv)
{
    // location of the machine running the "BlueGirl" head model
    std::string receiverHost = "localhost";
    
    if (argc > 2) {
        std::cout << "Usage: " << argv[0] << " <hostname>" << std::endl;
        std::cout << "The arguments specify the host of the head model "
                     "(Default: localhost)" << std::endl;
        return 1;
    }

    if (argc > 1) {
        receiverHost = std::string(argv[1]);
    }

    EmoEngineEventHandle eEvent = IEE_EmoEngineEventCreate();
    EmoStateHandle eState       = IEE_EmoStateCreate();
    unsigned int userID         = 0;
    const int CONTROL_PANEL_PORT = 3008;
    
    try {

        // Connect to EmoEngine
        if (IEE_EngineConnect() != EDK_OK) {
            throw std::runtime_error("EmoEngine start up failed.");
        }
        else {
            std::cout << "EmoEngine started!" << std::endl;
        }

        int startSendPort = 30000;
        std::map<unsigned int, SocketClient> socketMap;

        std::cout << "Type \"exit\" to quit, \"help\" to list available commands..."
                  << std::endl;
        promptUser();

        while (true) {

            // Handle the user input
            if (_kbhit()) {
                if (!handleUserInput()) {
                    break;
                }
            }

            int state = IEE_EngineGetNextEvent(eEvent);

            // New event needs to be handled
            if (state == EDK_OK) {

                IEE_Event_t eventType = IEE_EmoEngineEventGetType(eEvent);
                IEE_EmoEngineEventGetUserId(eEvent, &userID);

                switch (eventType) {

                // New headset connected
                // Create a new socket to send the animation
                case IEE_UserAdded:
                {
                    std::cout << std::endl << "New user " << userID
                              << " added, sending FacialExpression animation to ";
                    std::cout << receiverHost << ":" << startSendPort << "..."
                              << std::endl;
                    promptUser();

                    socketMap.insert(std::pair<unsigned int, SocketClient>(
                        userID, SocketClient(receiverHost, startSendPort, UDP)));

                    startSendPort++;
                    break;
                }

                // Headset disconnected, remove the existing socket
                case IEE_UserRemoved:
                {
                    std::cout << std::endl << "User " << userID
                              << " has been removed." << std::endl;

                    promptUser();
                    std::map<unsigned int, SocketClient>::iterator iter;
                    iter = socketMap.find(userID);
                    if (iter != socketMap.end()) {
                        socketMap.erase(iter);
                    }
                    break;
                }

                // Send the FacialExpression animation
                // if EmoState has been updated
                case IEE_EmoStateUpdated:
                {
                    IEE_EmoEngineEventGetEmoState(eEvent, eState);

                    std::map<unsigned int, SocketClient>::iterator iter;
                    iter = socketMap.find(userID);
                    if (iter != socketMap.end()) {
                        sendFacialExpressionAnimation(iter->second, eState);
                    }
                    break;
                }

                // Handle FacialExpression training event
                case IEE_FacialExpressionEvent:
                {
                    handleFacialExpressionEvent(std::cout, eEvent);
                }

                default:
                    break;
                }
            }
            else if (state != EDK_NO_EVENT) {
                std::cout << std::endl << "Internal error in Emotiv Engine!"
                          << std::endl;
                break;
            }

#ifdef _WIN32
            Sleep(15);
#endif
#ifdef __linux__
            sleep(1);
#endif
        }
    }
    catch (const std::runtime_error& e) {
        std::cerr << e.what() << std::endl;
        std::cout << "Press 'Enter' to exit..." << std::endl;
        getchar();
    }

    // Clean up
    IEE_EngineDisconnect();
    IEE_EmoStateFree(eState);
    IEE_EmoEngineEventFree(eEvent);

    return 0;
}
int main(int argc, char** argv) {

	EmoEngineEventHandle eEvent			= IEE_EmoEngineEventCreate();
	EmoStateHandle eState				= IEE_EmoStateCreate();
	unsigned int userID					= 0;
	const unsigned short composerPort	= 1726;
	float secs							= 1;
	unsigned int datarate				= 0;
	bool readytocollect					= false;
	int option							= 0;
	int state							= 0;


	std::string input;

	try {

		if (argc != 2) {
            throw std::runtime_error("Please supply the log file name.\n"
                                     "Usage: MultiChannelIEEGLogger [log_file_name].");
		}

        std::cout << "==================================================================="
                  << std::endl;
        std::cout << "Example to show how to log IEEG Data from "
                  << "EmoDriver/EmoComposer."
                  << std::endl;
        std::cout << "==================================================================="
                  << std::endl;
        std::cout << "Press '1' to start and connect to the Emotiv Driver "
                  << std::endl;
        std::cout << "Press '2' to connect to the EmoComposer         "
                  << std::endl;
		std::cout << ">> ";

		std::getline(std::cin, input, '\n');
		option = atoi(input.c_str());

		switch (option) {
			case 1:
			{
				if (IEE_EngineConnect() != EDK_OK) {
                    throw std::runtime_error(
                                "Emotiv Driver start up failed.");
				}
				break;
			}
			case 2:
			{
				std::cout << "Target IP of EmoComposer? [127.0.0.1] ";
				std::getline(std::cin, input, '\n');

				if (input.empty()) {
					input = std::string("127.0.0.1");
				}

				if (IEE_EngineRemoteConnect(input.c_str(), composerPort) != EDK_OK) {
                    std::string errMsg = "Cannot connect to EmoComposer on [" +
                                            input + "]";
                    throw std::runtime_error(errMsg.c_str());
				}
				break;
			}
			default:
                throw std::runtime_error("Invalid option...");
				break;
		}
		
		
        std::cout << "Start receiving IEEG Data! Press any key to stop logging...\n"
                  << std::endl;
    	std::ofstream ofs(argv[1],std::ios::trunc);
		ofs << header << std::endl;
		
		DataHandle hData = IEE_DataCreate();
		IEE_DataSetBufferSizeInSec(secs);

		std::cout << "Buffer size in secs:" << secs << std::endl;

		while (!_kbhit()) {

			state = IEE_EngineGetNextEvent(eEvent);

			if (state == EDK_OK) {

				IEE_Event_t eventType = IEE_EmoEngineEventGetType(eEvent);
				IEE_EmoEngineEventGetUserId(eEvent, &userID);

				// Log the EmoState if it has been updated
				if (eventType == IEE_UserAdded) {
					std::cout << "User added";
					IEE_DataAcquisitionEnable(userID,true);
					readytocollect = true;
				}
			}

			if (readytocollect) {

                IEE_DataUpdateHandle(0, hData);

                unsigned int nSamplesTaken=0;
                IEE_DataGetNumberOfSample(hData,&nSamplesTaken);

                std::cout << "Updated " << nSamplesTaken << std::endl;

                if (nSamplesTaken != 0) {
                    unsigned int channelCount = sizeof(targetChannelList)/
                                                sizeof(IEE_DataChannel_t);
                    double ** buffer = new double*[channelCount];
                    for (int i=0; i<channelCount; i++)
                        buffer[i] = new double[nSamplesTaken];

                    IEE_DataGetMultiChannels(hData, targetChannelList,
                                             channelCount, buffer, nSamplesTaken);

                    for (int sampleIdx=0 ; sampleIdx<(int)nSamplesTaken ;
                         ++ sampleIdx) {
                        for (int i = 0 ; i<sizeof(targetChannelList)/
                                           sizeof(IEE_DataChannel_t) ; i++) {

                            ofs << buffer[i][sampleIdx] << ",";
                        }
                        ofs << std::endl;
                    }
                    for (int i=0; i<channelCount; i++)
                        delete buffer[i];
                    delete buffer;
                }

			}

            std::this_thread::sleep_for(std::chrono::milliseconds(500));
		}

		ofs.close();
		IEE_DataFree(hData);

	}
    catch (const std::runtime_error& e) {
		std::cerr << e.what() << std::endl;
		std::cout << "Press any key to exit..." << std::endl;
		getchar();
	}

	IEE_EngineDisconnect();
	IEE_EmoStateFree(eState);
	IEE_EmoEngineEventFree(eEvent);

	return 0;
}
Beispiel #4
0
/* 
 *  Request double buffer display mode.
 *  Register mouse input callback functions
 */
int main(int argc, char** argv)
{
	EmoEngineEventHandle hEvent = IEE_EmoEngineEventCreate();
	EmoStateHandle eState = IEE_EmoStateCreate();
	unsigned int userID = -1;
	int state           = 0;
	bool ready          = false;
	
	if (IEE_EngineConnect() != EDK_OK) {
		std::cout << "Emotiv Driver start up failed.";
		return -1;
	}
	
	std::cout << "Please make sure your headset is on and don't move your head.";
	std::cout << std::endl;

	while(true)
	{

		state = IEE_EngineGetNextEvent(hEvent);

		if (state == EDK_OK) 
		{
		    IEE_Event_t eventType = IEE_EmoEngineEventGetType(hEvent);
			IEE_EmoEngineEventGetUserId(hEvent, &userID);

			if (eventType == IEE_UserAdded) {
		         std::cout << "User added" << std::endl << std::endl;
				 userID = 0;
		         ready = true;
			}
		}

		if(!ready) continue;

		int gyroX = 0, gyroY = 0;
		int err = IEE_HeadsetGetGyroDelta(userID, &gyroX, &gyroY);
				
		if (err == EDK_OK){
			std::cout << std::endl;
			std::cout << "You can move your head now." << std::endl;

#ifdef _WIN32
			Sleep(1000);
#endif
#if __linux__ || __APPLE__
            usleep(10000);
#endif
			break;
		}else if (err == EDK_GYRO_NOT_CALIBRATED){
			std::cout << "Gyro is not calibrated. Please stay still." << std::endl;
		}else if (err == EDK_CANNOT_ACQUIRE_DATA){
			std::cout << "Cannot acquire data" << std::endl;
		}else{
			std::cout << "No headset is connected" << std::endl;
		}

#ifdef _WIN32
		Sleep(100);
#endif
#if __linux__ || __APPLE__
        usleep(10000);
#endif
	}

#ifdef _WIN32
   globalElapsed = GetTickCount();
#endif
#if __linux__|| __APPLE__
   globalElapsed = ( unsigned long ) GetTickCount();
#endif

   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
   glutInitWindowSize (650, 650); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape); 
   glutIdleFunc(updateDisplay);
   glutMainLoop();  
      
   IEE_EngineDisconnect();
   IEE_EmoStateFree(eState);
   IEE_EmoEngineEventFree(hEvent);	

   return 0;
}
Beispiel #5
0
int main(int argc, char** argv) {

	EmoEngineEventHandle eEvent			= IEE_EmoEngineEventCreate();
	EmoStateHandle eState				= IEE_EmoStateCreate();
	unsigned int userID					= 0;	
	float secs							= 1;
	unsigned int datarate				= 0;
	bool readytocollect					= false;
	int state							= 0;

	try {

		if (argc != 2) {
            throw std::runtime_error("Please supply the log file name.\n"
                                     "Usage: MotionDataLogger [log_file_name].");
		}

        std::cout << "==================================================================="
                  << std::endl;
        std::cout << "Example to show how to log Motion Data from EmoDriver."
                  << std::endl;
        std::cout << "==================================================================="
                  << std::endl;

        
		if (IEE_EngineConnect() != EDK_OK) 
			throw std::runtime_error("Emotiv Driver start up failed.");
		
        std::cout << "Start receiving IEEG Data! "
                  << "Press any key to stop logging...\n"
                  << std::endl;

    	std::ofstream ofs(argv[1],std::ios::trunc);
		ofs << header << std::endl;
		
		DataHandle hMotionData = IEE_MotionDataCreate();
		IEE_MotionDataSetBufferSizeInSec(secs);

		std::cout << "Buffer size in secs:" << secs << std::endl;
		
		while (!_kbhit()) {

			state = IEE_EngineGetNextEvent(eEvent);
			if (state == EDK_OK) {

				IEE_Event_t eventType = IEE_EmoEngineEventGetType(eEvent);
				IEE_EmoEngineEventGetUserId(eEvent, &userID);

				// Log the EmoState if it has been updated
				if (eventType == IEE_UserAdded) {
					std::cout << "User added";
					readytocollect = true;
				}
			}

			if (readytocollect) {
						
                IEE_MotionDataUpdateHandle(0, hMotionData);

                unsigned int nSamplesTaken=0;
                IEE_MotionDataGetNumberOfSample(hMotionData, &nSamplesTaken);

                std::cout << "Updated " << nSamplesTaken << std::endl;

                if (nSamplesTaken != 0) {

                    double* data = new double[nSamplesTaken];
                    for (int sampleIdx=0 ; sampleIdx<(int)nSamplesTaken ; ++ sampleIdx) {
                        for (int i = 0 ;
                             i<sizeof(targetChannelList)/sizeof(IEE_MotionDataChannel_t) ;
                             i++) {

                            IEE_MotionDataGet(hMotionData, targetChannelList[i],
                                        data, nSamplesTaken);
                            ofs << data[sampleIdx] << ",";
                        }
                        ofs << std::endl;
                    }
                    delete[] data;
                }

			}

#ifdef _WIN32
            Sleep(1);
#endif
#ifdef __linux__
            usleep(10000);
#endif
		}

		ofs.close();
		IEE_MotionDataFree(hMotionData);
		

	}
    catch (const std::runtime_error& e) {
		std::cerr << e.what() << std::endl;
		std::cout << "Press any key to exit..." << std::endl;
		getchar();
	}

	IEE_EngineDisconnect();
	IEE_EmoStateFree(eState);
	IEE_EmoEngineEventFree(eEvent);

	return 0;
}
Beispiel #6
0
void  main() {
	std::string userName = "******";
	std::string password = "******";
	std::string profileName = "EmotivProfile";
	int version	= -1; // Lastest version

	int option	= 0;
	std::string input;
	bool ready  = false;

	EmoEngineEventHandle eEvent	= IEE_EmoEngineEventCreate();
	EmoStateHandle eState		= IEE_EmoStateCreate();
	unsigned int engineUserID	= -1;
	int userCloudID		= -1;
	int state			= 0;
		
	if (IEE_EngineConnect() != EDK_OK) {
                throw std::runtime_error(
                            "Emotiv Driver start up failed.");
	}

	std::cout << "==================================================================="
                << std::endl;
    std::cout << "Example to saving and loading profile from Emotiv Cloud "
                << std::endl;
    std::cout << "==================================================================="
                << std::endl;
    std::cout << "Press '1' to saving profile to Emotiv Cloud "
                << std::endl;
    std::cout << "Press '2' to loading profile from Emotiv Cloud "
                << std::endl;
	std::cout << ">> ";

	std::getline(std::cin, input, '\n');
	option = atoi(input.c_str());

	if(!EC_Connect())
	{
		std::cout << "Cannot connect to Emotiv Cloud";
		return;
	}

	if(!EC_Login(userName.c_str(), password.c_str()))
	{
			
		std::cout << "Your login attempt has failed. The username or password may be incorrect";
		_getch();
		return;
	}

	if (!EC_GetUserDetail(&userCloudID))
		return;

	while (!_kbhit())
	{
		state = IEE_EngineGetNextEvent(eEvent);

		if (state == EDK_OK) {

		IEE_Event_t eventType = IEE_EmoEngineEventGetType(eEvent);
		IEE_EmoEngineEventGetUserId(eEvent, &engineUserID);

		if (eventType == IEE_UserAdded) {
		std::cout << "User added" << std::endl;
		ready = true;
		}
		}

		if (ready)
		{
			int getNumberProfile = EC_GetAllProfileName(userCloudID);

			switch (option) {
				case 1:{    
					int profileID = EC_GetProfileId(userCloudID, profileName.c_str());

					if (profileID >= 0) {
						std::cout << "Profile with " << profileName << " is existed" << std::endl;
						if (EC_UpdateUserProfile(userCloudID, engineUserID, profileID, profileName.c_str())) {
						std::cout << "Updating finished";      
						}
						else std::cout << "Updating failed";
						}
					else if (EC_SaveUserProfile(userCloudID, (int)engineUserID, profileName.c_str(),
						profileFileType::TRAINING))
					{
						std::cout << "Saving finished";
					}
					else std::cout << "Saving failed";

					_getch();
					return;
				}
				case 2:{
					if (getNumberProfile > 0)
						if (EC_LoadUserProfile(userCloudID, (int)engineUserID, EC_ProfileIDAtIndex(userCloudID, 0)))
						std::cout << "Loading finished";
						else std::cout << "Loading failed";

					_getch();
					return;
				}
				default:
					throw std::runtime_error("Invalid option...");
					break;
			}
		}

#ifdef _WIN32
	Sleep(1);
#endif
#ifdef linux
	sleep(1);
#endif
	}

	IEE_EngineDisconnect();
	IEE_EmoStateFree(eState);
	IEE_EmoEngineEventFree(eEvent);
}
Beispiel #7
0
int main(int argc, char** argv) {

	EmoEngineEventHandle eEvent			= IEE_EmoEngineEventCreate();
	EmoStateHandle eState				= IEE_EmoStateCreate();
	unsigned int userID					= 0;
	const unsigned short composerPort	= 1726;
	int option = 0;
	int state  = 0;
	std::string input;

	try {

		if (argc != 2) {
            throw std::runtime_error("Please supply the log file name.\n"
                                     "Usage: EmoStateLogger [log_file_name].");
		}

        std::cout << "==================================================================="
                  << std::endl;
        std::cout << "Example to show how to log the EmoState from EmoEngine/EmoComposer."
                  << std::endl;
        std::cout << "==================================================================="
                  << std::endl;
        std::cout << "Press '1' to start and connect to the EmoEngine                    "
                  << std::endl;
        std::cout << "Press '2' to connect to the EmoComposer                            "
                  << std::endl;
		std::cout << ">> ";

		std::getline(std::cin, input, '\n');
		option = atoi(input.c_str());

		switch (option) {
        case 1:
        {
            if (IEE_EngineConnect() != EDK_OK) {
                throw std::runtime_error("Emotiv Driver start up failed.");
            }
            break;
        }
        case 2:
        {
            std::cout << "Target IP of EmoComposer? [127.0.0.1] ";
            std::getline(std::cin, input, '\n');

            if (input.empty()) {
                input = std::string("127.0.0.1");
            }

            if (IEE_EngineRemoteConnect(input.c_str(), composerPort) != EDK_OK) {
                std::string errMsg = "Cannot connect to EmoComposer on [" +
                                            input + "]";
                throw std::runtime_error(errMsg.c_str());
            }
            break;
        }
        default:
            throw std::runtime_error("Invalid option...");
            break;
		}
		
		
        std::cout << "Start receiving EmoState! Press any key to stop logging...\n"
                  << std::endl;

		std::ofstream ofs(argv[1]);
		bool writeHeader = true;
		
		while (!_kbhit()) {

			state = IEE_EngineGetNextEvent(eEvent);

			// New event needs to be handled
			if (state == EDK_OK) {

				IEE_Event_t eventType = IEE_EmoEngineEventGetType(eEvent);
				IEE_EmoEngineEventGetUserId(eEvent, &userID);

				// Log the EmoState if it has been updated
				if (eventType == IEE_EmoStateUpdated) {

					IEE_EmoEngineEventGetEmoState(eEvent, eState);
					const float timestamp = IS_GetTimeFromStart(eState);

                    printf("%10.3fs : New EmoState from user %d ...\r",
                           timestamp, userID);
					
					logEmoState(ofs, userID, eState, writeHeader);
					writeHeader = false;
				}
			}
			else if (state != EDK_NO_EVENT) {
				std::cout << "Internal error in Emotiv Engine!" << std::endl;
				break;
			}

#ifdef _WIN32
            Sleep(1);
#endif
#ifdef __linux__
            sleep(1);
#endif
		}

		ofs.close();
	}
    catch (const std::runtime_error& e) {
		std::cerr << e.what() << std::endl;
		std::cout << "Press any key to exit..." << std::endl;
		getchar();
	}

	IEE_EngineDisconnect();
	IEE_EmoStateFree(eState);
	IEE_EmoEngineEventFree(eEvent);

	return 0;
}