int MosMain(void) { MIL_ID MilApplication, /* Application Identifier. */ MilSystem, /* System Identifier. */ MilDisplay, /* Display Identifier. */ MilImage; /* Image buffer Identifier. */ long ReturnValue; /* Return Value holder. */ MIL_DOUBLE SynchronousCallTime, /* Timer variable. */ AsynchronousCallTime; /* Timer variable. */ int n; /* Counter. */ /* Allocate application, system and display. */ MappAlloc(M_DEFAULT, &MilApplication); MsysAlloc(SLAVE_SYSTEM_DESCRIPTOR, M_DEF_SYSTEM_NUM, M_SETUP, &MilSystem); MdispAlloc(MilSystem, M_DEV0, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDisplay); /* Restore source image into an automatically allocated image buffer. */ MbufRestore(IMAGE_FILE, MilSystem, &MilImage); /* Uncomment to display the image. */ /* MdispSelect(MilDisplay, MilImage); */ /* Pause */ MosPrintf(MIL_TEXT("\nMIL DTK:\n")); MosPrintf(MIL_TEXT("--------\n\n")); MosPrintf(MIL_TEXT("Custom synchronous and asynchronous MIL functions:\n\n")); MosPrintf(MIL_TEXT("This example times a synchronous and asynchronous custom function call.\n")); MosPrintf(MIL_TEXT("Press a key to continue.\n\n")); MosGetch(); /* Synchronous function call. */ /* -------------------------- */ /* Call the function a first time for more accurate timings later (dll load, ...). */ ReturnValue = SynchronousFunction(MilImage, MilImage, M_DEFAULT); /* Start the timer */ MappTimer(M_TIMER_RESET+M_SYNCHRONOUS, M_NULL); /* Loop many times for more precise timing. */ for (n= 0; n < NB_LOOP; n++) { /* Call the custom MIL synchronous function. */ ReturnValue = SynchronousFunction(MilImage, MilImage, M_DEFAULT); } /* Read the timer. */ MappTimer(M_TIMER_READ+M_SYNCHRONOUS, &SynchronousCallTime); /* Print the synchronous call time. */ MosPrintf(MIL_TEXT("Synchronous function call time: %.1f us.\n"), SynchronousCallTime*1000000/NB_LOOP); /* Asynchronous function call. */ /* --------------------------- */ /* Call the function a first time for more accurate timings later (dll load, ...). */ AsynchronousFunction(MilImage, MilImage, M_DEFAULT); MthrWait(M_DEFAULT, M_THREAD_WAIT, M_NULL); /* Start the timer */ MappTimer(M_TIMER_RESET+M_SYNCHRONOUS, M_NULL); /* Loop many times for more precise timing. */ for (n= 0; n < NB_LOOP; n++) { /* Call the custom MIL asynchronous function. */ AsynchronousFunction(MilImage, MilImage, M_DEFAULT); } /* Read and print the time. */ MappTimer(M_TIMER_READ+M_SYNCHRONOUS, &AsynchronousCallTime); /* Print the asynchronous call time. */ MosPrintf(MIL_TEXT("Asynchronous function call time: %.1f us.\n"), AsynchronousCallTime*1000000/NB_LOOP); MosPrintf(MIL_TEXT("Press a key to terminate.\n\n")); MosGetch(); /* Free all allocations. */ MbufFree(MilImage); MdispFree(MilDisplay); MsysFree(MilSystem); MappFree(MilApplication); 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."); } }
MIL_INT MFTYPE ProcessingFunction(MIL_INT HookType, MIL_ID EventId, void MPTYPE *CallBackDataPtr) { /* Get the grabbed buffer. */ ProcessingDataStruct *ProcessingDataPtr = (ProcessingDataStruct *)CallBackDataPtr; MIL_ID CurrentProcSrcBufId, CurrentProcDstBufId; MIL_ID GrabbedBufferId; MIL_INT GrabbedBufferIndex; MIL_TEXT_CHAR Text[BUFFER_MAX_STRING_LENGTH]; MIL_DOUBLE RectHalfSizeStep = 0.0; long RectStep = 0; long NbSystem = ProcessingDataPtr->NbSystem; long NbProcInitial = ProcessingDataPtr->NbProc; long NbBufferToProcess, n; /* Retrieve the buffer to process and it's index */ MdigGetHookInfo(EventId, M_MODIFIED_BUFFER+M_BUFFER_ID, &GrabbedBufferId); MdigGetHookInfo(EventId, M_MODIFIED_BUFFER+M_BUFFER_INDEX, &GrabbedBufferIndex); /* Reset the timer. */ if (ProcessingDataPtr->NbProc == 0) MappTimer(M_TIMER_RESET+M_SYNCHRONOUS,&ProcessingDataPtr->Time); /* If PROCESS_EACH_IMAGE_ON_ALL_SYSTEMS is set, each grabbed image is processed on all the systems. To have each frame processed only once by one system in round robin fashion, set the define to M_NO. */ if (ProcessingDataPtr->ProcessEachImageOnAllSystems) NbBufferToProcess = NbSystem; else NbBufferToProcess = 1; /* Dispatch the job to the target processing system(s) */ for(n=0; n<NbBufferToProcess; n++) { /* Calculate target processing buffer. */ CurrentProcSrcBufId = ProcessingDataPtr->SrcProcBufferListPtr[(ProcessingDataPtr->NbProc)%(NbSystem*BUFFER_PER_PROCESSOR)]; CurrentProcDstBufId = ProcessingDataPtr->DstProcBufferListPtr[(ProcessingDataPtr->NbProc)%(NbSystem*BUFFER_PER_PROCESSOR)]; /* Copy the grabbed buffer to a processing platform. */ MbufCopy(GrabbedBufferId, CurrentProcSrcBufId); /* Draw the buffer index in the source. */ MosSprintf(Text, BUFFER_MAX_STRING_LENGTH, MIL_TEXT("#%ld."), ProcessingDataPtr->NbProc); MgraText(M_DEFAULT, CurrentProcSrcBufId, 50, 50, Text); /* Process the buffer. */ #if (!M_MIL_LITE) { MimArith(CurrentProcSrcBufId, 0x10, CurrentProcDstBufId, M_SUB_CONST+M_SATURATION); MimArith(CurrentProcDstBufId, M_NULL, CurrentProcSrcBufId, M_NOT); MimRotate(CurrentProcSrcBufId, CurrentProcDstBufId, (ProcessingDataPtr->NbProc*10)%360, (MIL_DOUBLE) ProcessingDataPtr->SizeX/2, (MIL_DOUBLE) ProcessingDataPtr->SizeY/2, (MIL_DOUBLE) ProcessingDataPtr->SizeX/2, (MIL_DOUBLE) ProcessingDataPtr->SizeY/2, M_NEAREST_NEIGHBOR); } #else { RectStep = (ProcessingDataPtr->NbProc % BUFFER_DRAW_RECT_NUMBER); if(RectStep < BUFFER_DRAW_INWARD_STEP_NUMBER) RectHalfSizeStep = RectStep * BUFFER_DRAW_RECT_STEP; else RectHalfSizeStep = (BUFFER_DRAW_RECT_NUMBER - RectStep) * BUFFER_DRAW_RECT_STEP; MgraColor(M_DEFAULT, 0xff); MgraRectFill(M_DEFAULT, CurrentProcDstBufId, ProcessingDataPtr->SizeX/2 - RectHalfSizeStep, ProcessingDataPtr->SizeY/2 - RectHalfSizeStep, ProcessingDataPtr->SizeX/2 + RectHalfSizeStep, ProcessingDataPtr->SizeY/2 + RectHalfSizeStep); } #endif /* Count processed buffers. */ ProcessingDataPtr->NbProc++; MosPrintf(MIL_TEXT("Processing #%ld.\r"), ProcessingDataPtr->NbProc); } /* If required, copy back the result buffers from the processing system(s) for display. */ #if (DISPLAY_EACH_IMAGE_PROCESSED) { for(n=0; n<NbBufferToProcess; n++) { /* Calculate target buffer for display. */ CurrentProcDstBufId = ProcessingDataPtr->DstProcBufferListPtr[(NbProcInitial+n)%(NbSystem*BUFFER_PER_PROCESSOR)]; /* Copy result to display. */ MbufCopy(CurrentProcDstBufId, ProcessingDataPtr->DispBuffer); } } #endif /* Read the timer. */ MappTimer(M_TIMER_READ+M_SYNCHRONOUS, &ProcessingDataPtr->Time); #if M_MIL_USE_CE /* Give execution time to user interface when the digitizer processing queue is full. If necessary, the Sleep value can be increased to give more execution time to user interface. */ if(MdigInquire(ProcessingDataPtr->MilDigitizer, M_PROCESS_PENDING_GRAB_NUM, M_NULL) <= 1) { if ((ProcessingDataPtr->NbProc%10) == 0) Sleep(2); } #endif return(0); }