void RouteFinder::runProcess() {
cv::Mat grayImg, image;
ushort imgCntBendCrossing = 0;
ushort imgCntDone = 0;
ushort setSpeedCnt = 0;
m_Running = true;
m_Controller->printString("Start", me, 1);
while(m_Running) {
image = m_PicCreator->GetImage();
if (!image.empty()) {
cv::cvtColor(image,grayImg,CV_BGR2GRAY);
cv::Mat fltImg = cv::Mat::zeros(grayImg.rows, grayImg.cols, CV_8UC1);
if (m_Rows == 0) {
m_Rows = grayImg.rows;
m_Cols = grayImg.cols;
}
edgeDetection(&grayImg, &fltImg);
m_GrayImg = grayImg.clone();
m_FinalFltImg = fltImg.clone();
outPutNrOfIms(imgCntDone);
setDriveState(setSpeedCnt);
checkLaneLost();
setBendCheck(imgCntBendCrossing);
setCrossingSearchState(imgCntBendCrossing);
checkCrossingPriorityLane();
checkTargetFieldFound();
checkMaxNrOfImgsReached(imgCntDone);
}
}
m_Controller->printString("Stop", me, 1);
}
/*
* Return TRUE if any drives are available
* in any of the libraries.
*/
int
IfDrivesAvail(void)
{
int i;
int avail;
LibraryInfo_t *lib;
ReconfigLock(); /* wait on reconfig */
(void) setDriveState(B_TRUE);
avail = 0;
for (i = 0; i < libraryTable.entries; i++) {
lib = &libraryTable.data[i];
/*
* If not historian or third party, add number of
* drives available.
*/
if (!IS_LIB_HISTORIAN(lib) && !IS_LIB_THIRDPARTY(lib)) {
avail += lib->li_numAvailDrives;
}
}
ReconfigUnlock(); /* allow reconfig */
return (avail != 0);
}
/*
* Check if specified drive is free.
*/
int
IsDriveFree(
int drive)
{
DriveInfo_t *entry;
(void) setDriveState(B_TRUE);
entry = &driveTable.data[drive];
return (IS_DRIVE_AVAIL(entry) && (IS_DRIVE_BUSY(entry) == 0));
}
/*
* Initialize table of media libraries for stager. This function
* builds tables for the libraries, removable media drives and manual
* drives from shared memory.
*/
static void
initLibraryTable(void)
{
extern char *program_name;
int jmap;
dev_ent_t *dev;
size_t size;
LibraryInfo_t *lib;
DriveInfo_t *drive;
int ldx;
int ddx;
dev_ent_t *dev_head;
int numDiskVols;
int numHoneycombVols;
DiskVolsDictionary_t *diskvols;
boolean_t found_historian = B_FALSE;
/*
* If table already exists, free current table
* and re-initialize.
*/
if (libraryTable.data != NULL) {
SamFree(libraryTable.data);
SamFree(driveTable.data);
libraryTable.data = NULL;
driveTable.data = NULL;
}
if (vsnTable.data != NULL) {
SamFree(vsnTable.data);
vsnTable.data = NULL;
if (vsnTable.catalog == B_TRUE) {
CatalogTerm();
vsnTable.catalog = B_FALSE;
}
}
libraryTable.entries = 0;
driveTable.entries = 0;
vsnTable.entries = 0;
dev_head = GetDevices(B_FALSE);
for (dev = dev_head; dev != NULL;
dev = (struct dev_ent *)SHM_REF_ADDR(dev->next)) {
if (dev->equ_type == DT_HISTORIAN) {
libraryTable.entries++;
found_historian = B_TRUE;
} else if (IS_THIRD_PARTY(dev)) {
libraryTable.entries++;
foundThirdParty = B_TRUE;
} else if (IS_ROBOT(dev) || dev->equ_type == DT_PSEUDO_SC) {
dev_ent_t *find;
libraryTable.entries++;
/*
* Find all drives belonging to this library.
*/
for (find = dev_head; find != NULL;
find = (struct dev_ent *)SHM_REF_ADDR(find->next)) {
if (find->eq != dev->eq) {
if (find->fseq == dev->eq) {
driveTable.entries++;
}
}
}
} else if (dev->fseq == 0) {
/*
* Manual drive.
*/
libraryTable.entries++;
driveTable.entries++;
manualDrives++;
}
}
Trace(TR_MISC, "Removable media libraries: %d drives: %d",
found_historian ? libraryTable.entries - 1 : libraryTable.entries,
driveTable.entries);
/*
* If defined, allocate a library table for disk archiving.
* The disk archiving library will have a disk drive defined
* for each vsn.
*/
numDiskVols = 0;
numHoneycombVols = 0;
diskvols = DiskVolsNewHandle(program_name, DISKVOLS_VSN_DICT, 0400);
if (diskvols != NULL) {
(void) diskvols->Numof(diskvols, &numDiskVols, DV_numof_disk);
(void) diskvols->Numof(diskvols, &numHoneycombVols,
DV_numof_honeycomb);
(void) DiskVolsDeleteHandle(DISKVOLS_VSN_DICT);
}
if (numDiskVols > 0) {
libraryTable.entries++;
driveTable.entries += numDiskVols * STREAMS_PER_DISKVOL;
Trace(TR_MISC, "Disk volumes: %d", numDiskVols);
}
if (numHoneycombVols > 0) {
libraryTable.entries++;
driveTable.entries += numHoneycombVols;
Trace(TR_MISC, "Stk5800 volumes: %d", numHoneycombVols);
}
/*
* Issue message if no removable media or disk archive volumes
* were found.
*/
if (libraryTable.entries == 0 ||
(found_historian && libraryTable.entries == 1)) {
SendCustMsg(HERE, 19007);
}
/*
* Allocate library and drive tables and enter data. If the
* table count is zero, allocate one table entry anyway.
*/
size = (libraryTable.entries ? libraryTable.entries : 1)
* sizeof (LibraryInfo_t);
SamMalloc(libraryTable.data, size);
(void) memset(libraryTable.data, 0, size);
size = (driveTable.entries ? driveTable.entries : 1)
* sizeof (DriveInfo_t);
SamMalloc(driveTable.data, size);
(void) memset(driveTable.data, 0, size);
lib = libraryTable.data;
drive = driveTable.data;
ldx = 0;
ddx = 0;
for (dev = dev_head; dev != NULL;
dev = (struct dev_ent *)SHM_REF_ADDR(dev->next)) {
lib->li_flags = 0;
lib->li_device = dev;
if (dev->type == DT_HISTORIAN) {
(void) strncpy(lib->li_name, "Historian",
sizeof (lib->li_name));
SET_LIB_HISTORIAN(lib);
lib->li_eq = dev->eq;
lib->li_numDrives = manualDrives;
} else if (IS_THIRD_PARTY(dev)) {
(void) strncpy(lib->li_name, "ThirdParty",
sizeof (lib->li_name));
SET_LIB_THIRDPARTY(lib);
lib->li_eq = dev->eq;
(void) InitMigration(dev);
} else if (IS_ROBOT(dev) || dev->equ_type == DT_PSEUDO_SC) {
dev_ent_t *find;
memcpy(lib->li_name, dev->set, sizeof (lib->li_name));
lib->li_eq = dev->eq;
/* Check if remote sam client */
if (dev->equ_type == DT_PSEUDO_SC) {
SET_LIB_REMOTE(lib);
}
/*
* Find all drives belonging to this library.
*/
find = dev_head; /* Head of dev entries */
for (find = dev_head; find != NULL;
find = (struct dev_ent *)SHM_REF_ADDR(find->next)) {
if (find->eq != dev->eq) {
if (find->fseq == dev->eq) {
lib->li_numDrives++;
sprintf(drive->dr_name, "%s%d",
sam_mediatoa(find->type),
find->eq);
drive->dr_device = find;
drive->dr_lib = ldx;
/*
* Increment to next drive
* table entry.
*/
drive++;
ddx++;
}
}
}
} else if (dev->fseq == 0) {
/*
* Manual drive.
*/
sprintf(lib->li_name, "%s%d", sam_mediatoa(dev->type),
dev->eq);
SET_LIB_MANUAL(lib);
lib->li_numDrives = 1;
lib->li_manual = ddx;
lib->li_eq = dev->eq;
sprintf(drive->dr_name, "%s%d", sam_mediatoa(dev->type),
dev->eq);
drive->dr_device = dev;
drive->dr_lib = ldx;
/* Increment to next drive table entry. */
drive++;
ddx++;
} else {
/* Not a library, continue to next dev entry. */
continue;
}
/*
* Set number of drives allowed. Increment to next
* library table entry.
*/
lib->li_numAllowedDrives = lib->li_numDrives;
lib++;
ldx++;
}
if (numDiskVols > 0) {
char *mtype;
mtype = sam_mediatoa(DT_DISK);
(void) strncpy(lib->li_name, mtype, sizeof (lib->li_name));
SET_LIB_DISK(lib);
SET_LIB_AVAIL(lib);
lib->li_numDrives = numDiskVols * STREAMS_PER_DISKVOL;
lib->li_numAllowedDrives = numDiskVols * STREAMS_PER_DISKVOL;
lib->li_numAvailDrives = numDiskVols * STREAMS_PER_DISKVOL;
/*
* Define drives belonging to disk archive library.
*/
for (jmap = 0; jmap < numDiskVols * STREAMS_PER_DISKVOL;
jmap++) {
sprintf(drive->dr_name, "%s%d", mtype, jmap);
drive->dr_lib = ldx;
SET_DRIVE_AVAIL(drive);
/* Increment to next drive table entry. */
drive++;
ddx++;
}
lib++;
ldx++;
}
if (numHoneycombVols > 0) {
char *mtype;
mtype = sam_mediatoa(DT_STK5800);
(void) strncpy(lib->li_name, mtype, sizeof (lib->li_name));
SET_LIB_HONEYCOMB(lib);
SET_LIB_AVAIL(lib);
lib->li_numDrives = numHoneycombVols;
lib->li_numAllowedDrives = numHoneycombVols;
lib->li_numAvailDrives = numHoneycombVols;
/*
* Define drives belonging to honeycomb archive library.
*/
for (jmap = 0; jmap < numHoneycombVols; jmap++) {
sprintf(drive->dr_name, "%s%d", mtype, jmap);
drive->dr_lib = ldx;
SET_DRIVE_AVAIL(drive);
/* Increment to next drive table entry. */
drive++;
ddx++;
}
}
(void) setDriveState(B_FALSE); /* get current drive state */
}
