MdispQtApp::MdispQtApp( int& argc, char** argv )
: QApplication( argc, argv )
, m_isCurrentlyHookedOnErrors(false)
, m_ErrorEventSemaphore(1)
, m_CreatorThread( QThread::currentThreadId() )
{
// Set semaphore to initial state (no error event available).
m_ErrorEventSemaphore.acquire();
// Allocate an application and system [CALL TO MIL]
MappAllocDefault(M_DEFAULT, &m_MilApplication, &m_MilSystem, M_NULL, M_NULL, M_NULL);
// Hook MIL error on function DisplayError() [CALL TO MIL]
MappHookFunction(M_ERROR_CURRENT,DisplayErrorExt,M_NULL);
m_isCurrentlyHookedOnErrors = true;
// Disable MIL error message to be displayed as the usual way [CALL TO MIL]
MappControl(M_ERROR,M_PRINT_DISABLE);
// Inquire number of digitizers available on the system [CALL TO MIL]
MsysInquire(m_MilSystem,M_DIGITIZER_NUM,&m_numberOfDigitizer);
// Digitizer is available
if (m_numberOfDigitizer)
{
// Allocate a digitizer [CALL TO MIL]
MdigAlloc(m_MilSystem,M_DEFAULT,M_CAMERA_SETUP,M_DEFAULT,&m_MilDigitizer);
// Stop live grab when window is disable [CALL TO MIL]
//TBM MIL 8.0 MsysControl(MilSystem,M_STOP_LIVE_GRAB_WHEN_DISABLED,M_ENABLE);
// Inquire digitizer informations [CALL TO MIL]
MdigInquire(m_MilDigitizer,M_SIZE_X,&m_digitizerSizeX);
MdigInquire(m_MilDigitizer,M_SIZE_Y,&m_digitizerSizeY);
MdigInquire(m_MilDigitizer,M_SIZE_BAND,&m_digitizerNbBands);
if (m_digitizerSizeX > M_DEF_IMAGE_SIZE_X_MAX)
m_digitizerSizeX = M_DEF_IMAGE_SIZE_X_MAX;
if (m_digitizerSizeY > M_DEF_IMAGE_SIZE_Y_MAX)
m_digitizerSizeY = M_DEF_IMAGE_SIZE_Y_MAX;
}
// Digitizer is not available
else
{
m_MilDigitizer = 0;
m_digitizerNbBands = M_DEF_IMAGE_NUMBANDS_MIN;
}
// Initialize the state of the grab
m_isGrabStarted = FALSE;
// Initialize GUI
MainFrame* mf = new MainFrame();
//setMainWidget(mf);
mf->show();
}
bool MdispGtkApp::InitInstance()
{
// Allocate an application and system [CALL TO MIL]
MappAllocDefault(M_DEFAULT, &m_MilApplication, &m_MilSystem, M_NULL, M_NULL, M_NULL);
// Hook MIL error on function DisplayError() [CALL TO MIL]
MappHookFunction(M_ERROR_CURRENT,DisplayErrorExt,this);
m_isCurrentlyHookedOnErrors = true;
// Disable MIL error message to be displayed as the usual way [CALL TO MIL]
MappControl(M_ERROR,M_PRINT_DISABLE);
// Inquire number of digitizers available on the system [CALL TO MIL]
MsysInquire(m_MilSystem,M_DIGITIZER_NUM,&m_numberOfDigitizer);
// Digitizer is available
if (m_numberOfDigitizer)
{
// Allocate a digitizer [CALL TO MIL]
MdigAlloc(m_MilSystem,M_DEFAULT,M_CAMERA_SETUP,M_DEFAULT,&m_MilDigitizer);
// Stop live grab when window is disable [CALL TO MIL]
//TBM MIL 8.0 MsysControl(MilSystem,M_STOP_LIVE_GRAB_WHEN_DISABLED,M_ENABLE);
// Inquire digitizer informations [CALL TO MIL]
MdigInquire(m_MilDigitizer,M_SIZE_X,&m_digitizerSizeX);
MdigInquire(m_MilDigitizer,M_SIZE_Y,&m_digitizerSizeY);
MdigInquire(m_MilDigitizer,M_SIZE_BAND,&m_digitizerNbBands);
if (m_digitizerSizeX > M_DEF_IMAGE_SIZE_X_MAX)
m_digitizerSizeX = M_DEF_IMAGE_SIZE_X_MAX;
if (m_digitizerSizeY > M_DEF_IMAGE_SIZE_Y_MAX)
m_digitizerSizeY = M_DEF_IMAGE_SIZE_Y_MAX;
}
else
{
m_MilDigitizer=0;
m_digitizerNbBands = M_DEF_IMAGE_NUMBANDS_MIN;
}
// Initialize the state of the grab
m_isGrabStarted = false;
return true;
}
int MosMain(void)
{
MIL_ID MilApplication, /* Application identifier. */
MilSystem, /* System identifier. */
MilDisplay, /* Display identifier. */
MilImage; /* Image buffer identifier. */
/* Allocate a default MIL application, system, display and image. */
MappAllocDefault(M_SETUP, &MilApplication, &MilSystem, &MilDisplay, M_NULL, &MilImage);
/* If no allocation errors. */
if (!MappGetError(M_GLOBAL, M_NULL))
{
/* Perform graphic operations in the display image. */
MgraColor(M_DEFAULT, 0xF0);
MgraFont(M_DEFAULT, M_FONT_DEFAULT_LARGE);
MgraText(M_DEFAULT, MilImage, 160L, 230L, MIL_TEXT(" Welcome to MIL !!! "));
MgraColor(M_DEFAULT, 0xC0);
MgraRect(M_DEFAULT, MilImage, 100L, 150L, 530L, 340L);
MgraRect(M_DEFAULT, MilImage, 120L, 170L, 510L, 320L);
MgraRect(M_DEFAULT, MilImage, 140L, 190L, 490L, 300L);
/* Print a message. */
MosPrintf(MIL_TEXT("\nSYSTEM ALLOCATION:\n"));
MosPrintf(MIL_TEXT("------------------\n\n"));
MosPrintf(MIL_TEXT("System allocation successful.\n\n"));
MosPrintf(MIL_TEXT(" \"Welcome to MIL !!!\"\n\n"));
}
else
MosPrintf(MIL_TEXT("System allocation error !\n\n"));
/* Wait for a key press. */
MosPrintf(MIL_TEXT("Press <Enter> to end.\n"));
MosGetch();
/* Free defaults. */
MappFreeDefault(MilApplication, MilSystem, MilDisplay, M_NULL, MilImage);
return 0;
}
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
// validate the command string
if(nrhs < 1 || mxIsChar(prhs[0]) != 1 || mxGetM(prhs[0]) != 1) {
mexErrMsgTxt("Missing command string.");
}
// get the command
int cmdlen = mxGetN(prhs[0]) + 1;
char* command = (char*)mxCalloc(cmdlen, sizeof(char));
if(mxGetString(prhs[0], command, cmdlen) != 0) {
mexErrMsgTxt("Get command string failed.");
}
// startup
if(strcmp(command, "init") == 0) {
// set things up so a clear will also clean up
mexAtExit(cleanup);
if(nrhs > 1) {
if(!mxIsChar(prhs[1]) || mxGetM(prhs[1]) != 1) {
mexErrMsgTxt("init argument should be the name of a dcf file.");
}
int nmlen = mxGetN(prhs[1]) + 1;
char* dcfname = (char*)mxCalloc(nmlen, sizeof(char));
mxGetString(prhs[1], dcfname, nmlen);
MappAllocDefault(M_SETUP, &MilApplication, &MilSystem,
M_NULL, M_NULL, M_NULL);
if(MdigAlloc(MilSystem, M_DEV0, dcfname, M_DEFAULT, &MilDigitizer) == M_NULL) {
mexErrMsgTxt("init failed.");
}
} else {
/* Allocate defaults. */
MappAllocDefault(M_SETUP, &MilApplication, &MilSystem,
M_NULL, &MilDigitizer, M_NULL);
}
MBands = (int)MdigInquire(MilDigitizer, M_SIZE_BAND, M_NULL);
for(int i=0; i<MBands; i++)
band_is_selected[i] = true;
bands_selected = MBands;
MappTimer(M_TIMER_RESET, M_NULL);
grab_scale_x = grab_scale_y = 1;
MdigControl(MilDigitizer, M_GRAB_MODE, M_ASYNCHRONOUS);
MdigControl(MilDigitizer, M_GRAB_SCALE_X, grab_scale_x);
MdigControl(MilDigitizer, M_GRAB_SCALE_Y, grab_scale_y);
// wrapup
} else if(strcmp(command, "quit") == 0) {
cleanup();
// set the x and y scaling factor
} else if(strcmp(command, "setscale") == 0) {
// check the parameters
if(nrhs != 3 || !mxIsDouble(prhs[1]) || !mxIsDouble(prhs[2])) {
mexErrMsgTxt("setscale expects 2 arguments.");
}
grab_scale_x = mxGetScalar(prhs[1]);
grab_scale_y = mxGetScalar(prhs[2]);
MdigControl(MilDigitizer, M_GRAB_SCALE_X, grab_scale_x);
MdigControl(MilDigitizer, M_GRAB_SCALE_Y, grab_scale_y);
// select which bands to return for multiband sources
} else if(strcmp(command, "selectbands") == 0) {
// check to see if it's legal
if(MBands == 1) {
mexErrMsgTxt("selectbands only works for multiband sources.");
}
// check the argument
if(nrhs != 2 || !mxIsDouble(prhs[1]) || mxGetM(prhs[1]) != 1) {
mexErrMsgTxt("selectbands expects a row vector of band numbers.");
}
int nbands = mxGetN(prhs[1]);
if(nbands == 0 || nbands > MBands) {
mexErrMsgTxt("selectbands allows only 1 to 3 bands.");
}
double* bp = mxGetPr(prhs[1]);
for(int i=0; i<3; i++) {
band_is_selected[i] = false;
}
bands_selected = 0;
for(i=0; i<nbands; i++) {
int bnd = int(bp[i]);
if(bnd < 0 || bnd > 2) {
mexErrMsgTxt("selectbands allows bands numbered 0 to 2.");
}
if(!band_is_selected[bnd]) {
band_is_selected[bnd] = true;
bands_selected++;
}
}
// grab a sequence in one call
} else if(strcmp(command, "grabframes") == 0) {
// check the parameters
if(nrhs < 4 || !mxIsDouble(prhs[1]) || !mxIsDouble(prhs[2]) || !mxIsDouble(prhs[3])) {
mexErrMsgTxt("grabframes expects 3 or 4 arguments.");
}
int width = int(mxGetScalar(prhs[1]));
int height = int(mxGetScalar(prhs[2]));
int frames = int(mxGetScalar(prhs[3]));
// indicates whether this is a continuation of a previous grab
bool grab_continue = false;
if(nrhs == 5 && mxIsDouble(prhs[4]) && mxGetScalar(prhs[4]) > 0) {
grab_continue = true;
}
// space to record per frame times if requested
mxArray *time_array = 0;
double* time_data = 0;
if(nlhs > 1) {
time_array = mxCreateDoubleMatrix(frames, 1, mxREAL);
time_data = mxGetPr(time_array);
}
// allocate a matlab multidimensional array to return the image
int dims[4];
int ndims = 3;
dims[0] = height;
dims[1] = width;
if(bands_selected > 1) {
dims[2] = bands_selected;
dims[3] = frames;
ndims = 4;
} else {
dims[2] = frames;
}
mxArray *res = mxCreateNumericArray(ndims, dims, mxUINT8_CLASS, mxREAL);
int frameelements = width*height*MBands;
unsigned char* pmat = (unsigned char*)mxGetPr(res);
// free buffers if they are the wrong size
if(MilImageX != 0 && (width != MilImageX || height != MilImageY)) {
MdigGrabWait(MilDigitizer, M_GRAB_END);
for(int n=0; n<nmilbuff; n++) {
MbufFree(MilImage[n]);
}
MilImageX = MilImageY = 0;
}
// allocate a few MIL buffers if we don't already have them
if(MilImageX == 0) {
for (int n=0; n<nmilbuff; n++)
{
MbufAllocColor(MilSystem,
MBands,
width,
height,
8L+M_UNSIGNED,
M_IMAGE+M_GRAB, &MilImage[n]);
if (MilImage[n] == 0)
{
mexErrMsgTxt("MbufAllocColor failed.");
}
}
MilImageX = width;
MilImageY = height;
}
// grab the frames
if(!grab_continue) {
// if you're not continuing a previous grab, then you want a fresh first frame
MdigGrab(MilDigitizer, MilImage[MilImageNdx]);
}
for(int i = 0; i < frames; i++)
{
int ndx0 = MilImageNdx;
MilImageNdx = (MilImageNdx + 1) % nmilbuff;
MdigGrab(MilDigitizer, MilImage[MilImageNdx]);
if(time_array)
MappTimer(M_TIMER_READ, &time_data[i]);
// copy the completed buff to the matlab array
if(MBands == 1) { // easy
// get a pointer to the buffer
unsigned char* pmil;
MbufInquire(MilImage[ndx0], M_HOST_ADDRESS, &pmil);
if(pmil == M_NULL) {
mexErrMsgTxt("no access to mil buffer.");
}
// copy the pixels exchanging x and y coordinates to suit matlab
for(int y=0; y<height; y++) {
for(int x=0; x<width; x++) {
pmat[y+x*height] = pmil[x+y*width];
}
}
pmat += width*height;
} else { // harder
// I bet there is some smarter way to do this...
// for each band
for(int b=0; b<MBands; b++) {
if(band_is_selected[b]) {
// allocate a child buffer on the band.
MIL_ID child = MbufChildColor(MilImage[ndx0], b, M_NULL);
if(child == M_NULL) {
mexErrMsgTxt("no child");
}
// get a pointer to the child
unsigned char* pmil;
MbufInquire(child, M_HOST_ADDRESS, &pmil);
if(pmil == M_NULL) {
MbufFree(child);
mexErrMsgTxt("no access to mil buffer.");
}
// do the copy, twizzling the indicies around...
for(int y=0; y<height; y++) {
for(int x=0; x<width; x++) {
pmat[(y + x*height)] = pmil[x+y*width];
}
}
pmat += width*height;
// release the child
MbufFree(child);
}
}
}
}
plhs[0] = res;
if(time_array)
plhs[1] = time_array;
} else {
mexErrMsgTxt("Unknown command string.");
}
}
