bool CGUIControlRangeSetting::OnClick()
{
if (m_pSlider == NULL ||
m_pSetting->GetType() != SettingTypeList)
return false;
CSettingList *settingList = static_cast<CSettingList*>(m_pSetting);
const SettingPtrList &settingListValues = settingList->GetValue();
if (settingListValues.size() != 2)
return false;
std::vector<CVariant> values;
const CSetting *listDefintion = settingList->GetDefinition();
switch (listDefintion->GetType())
{
case SettingTypeInteger:
values.push_back(m_pSlider->GetIntValue(CGUISliderControl::RangeSelectorLower));
values.push_back(m_pSlider->GetIntValue(CGUISliderControl::RangeSelectorUpper));
break;
case SettingTypeNumber:
values.push_back(m_pSlider->GetFloatValue(CGUISliderControl::RangeSelectorLower));
values.push_back(m_pSlider->GetFloatValue(CGUISliderControl::RangeSelectorUpper));
break;
default:
return false;
}
if (values.size() != 2)
return false;
SetValid(CSettingUtils::SetList(settingList, values));
return IsValid();
}
bool CSettings::SetList(const std::string &id, const std::vector<CVariant> &value)
{
CSetting *setting = m_settingsManager->GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeList)
return false;
CSettingList *listSetting = static_cast<CSettingList*>(setting);
SettingPtrList newValues;
bool ret = true;
int index = 0;
for (std::vector<CVariant>::const_iterator itValue = value.begin(); itValue != value.end(); ++itValue)
{
CSetting *settingValue = listSetting->GetDefinition()->Clone(StringUtils::Format("%s.%d", listSetting->GetId().c_str(), index++));
if (settingValue == NULL)
return false;
switch (listSetting->GetElementType())
{
case SettingTypeBool:
if (!itValue->isBoolean())
return false;
ret = static_cast<CSettingBool*>(settingValue)->SetValue(itValue->asBoolean());
break;
case SettingTypeInteger:
if (!itValue->isInteger())
return false;
ret = static_cast<CSettingInt*>(settingValue)->SetValue((int)itValue->asInteger());
break;
case SettingTypeNumber:
if (!itValue->isDouble())
return false;
ret = static_cast<CSettingNumber*>(settingValue)->SetValue(itValue->asDouble());
break;
case SettingTypeString:
if (!itValue->isString())
return false;
ret = static_cast<CSettingString*>(settingValue)->SetValue(itValue->asString());
break;
default:
ret = false;
break;
}
if (!ret)
{
delete settingValue;
return false;
}
newValues.push_back(SettingPtr(settingValue));
}
return listSetting->SetValue(newValues);
}
std::vector<CVariant> CSettings::GetList(const std::string &id) const
{
CSetting *setting = m_settingsManager->GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeList)
return std::vector<CVariant>();
CSettingList *listSetting = static_cast<CSettingList*>(setting);
return ListToValues(listSetting, listSetting->GetValue());
}
/**
* Construct the control (first phase).
* Creates an instance and initializes it.
* Instance is left on cleanup stack.
* @param aRect The rectangle for this window
* @param aParent owning parent, or NULL
* @param aCommandObserver command observer
* @return new instance of CSettingList
*/
CSettingList* CSettingList::NewLC(
const TRect& aRect,
const CCoeControl* aParent,
MEikCommandObserver* aCommandObserver )
{
CSettingList* self = new ( ELeave ) CSettingList();
CleanupStack::PushL( self );
self->ConstructL( aRect, aParent, aCommandObserver );
return self;
}
CGUIControlRangeSetting::CGUIControlRangeSetting(CGUISettingsSliderControl *pSlider, int id, CSetting *pSetting)
: CGUIControlBaseSetting(id, pSetting)
{
m_pSlider = pSlider;
if (m_pSlider == NULL)
return;
m_pSlider->SetID(id);
m_pSlider->SetRangeSelection(true);
if (m_pSetting->GetType() == SettingTypeList)
{
CSettingList *settingList = static_cast<CSettingList*>(m_pSetting);
const CSetting *listDefintion = settingList->GetDefinition();
switch (listDefintion->GetType())
{
case SettingTypeInteger:
{
const CSettingInt *listDefintionInt = static_cast<const CSettingInt*>(listDefintion);
if (m_pSetting->GetControl()->GetFormat() == "percentage")
m_pSlider->SetType(SLIDER_CONTROL_TYPE_PERCENTAGE);
else
{
m_pSlider->SetType(SLIDER_CONTROL_TYPE_INT);
m_pSlider->SetRange(listDefintionInt->GetMinimum(), listDefintionInt->GetMaximum());
}
m_pSlider->SetIntInterval(listDefintionInt->GetStep());
break;
}
case SettingTypeNumber:
{
const CSettingNumber *listDefinitionNumber = static_cast<const CSettingNumber*>(listDefintion);
m_pSlider->SetType(SLIDER_CONTROL_TYPE_FLOAT);
m_pSlider->SetFloatRange((float)listDefinitionNumber->GetMinimum(), (float)listDefinitionNumber->GetMaximum());
m_pSlider->SetFloatInterval((float)listDefinitionNumber->GetStep());
break;
}
default:
break;
}
}
Update();
}
CSettingList* CGUIDialogSettingsManualBase::AddRange(CSettingGroup *group, const std::string &id, int label, int level, float valueLower, float valueUpper, float minimum,
float step, float maximum, const std::string &format, int formatLabel, int valueFormatLabel,
const std::string &valueFormatString, bool delayed, bool visible, int help)
{
if (group == NULL || id.empty() || label < 0 ||
GetSetting(id) != NULL)
return NULL;
CSettingNumber *settingDefinition = new CSettingNumber(id, m_settingsManager);
if (settingDefinition == NULL)
return NULL;
settingDefinition->SetMinimum(minimum);
settingDefinition->SetStep(step);
settingDefinition->SetMaximum(maximum);
CSettingList *setting = new CSettingList(id, settingDefinition, label, m_settingsManager);
if (setting == NULL)
{
delete settingDefinition;
return NULL;
}
std::vector<CVariant> valueList;
valueList.push_back(valueLower);
valueList.push_back(valueUpper);
SettingPtrList settingValues;
if (!CSettingUtils::ValuesToList(setting, valueList, settingValues))
{
delete settingDefinition;
delete setting;
return NULL;
}
// setting the default will also set the actual value on an unchanged setting
setting->SetDefault(settingValues);
setting->SetControl(GetRangeControl(format, delayed, formatLabel, valueFormatLabel, valueFormatString));
setting->SetMinimumItems(2);
setting->SetMaximumItems(2);
setSettingDetails(setting, level, visible, help);
group->AddSetting(setting);
return setting;
}
CSettingList* CGUIDialogSettingsManualBase::AddList(CSettingGroup *group, const std::string &id, int label, int level, std::vector<int> values,
IntegerSettingOptionsFiller filler, int heading, int minimumItems /* = 0 */, int maximumItems /* = -1 */,
bool visible /* = true */, int help /* = -1 */)
{
if (group == NULL || id.empty() || label < 0 || filler == NULL ||
GetSetting(id) != NULL)
return NULL;
CSettingInt *settingDefinition = new CSettingInt(id, m_settingsManager);
if (settingDefinition == NULL)
return NULL;
settingDefinition->SetOptionsFiller(filler, this);
CSettingList *setting = new CSettingList(id, settingDefinition, label, m_settingsManager);
if (setting == NULL)
{
delete settingDefinition;
return NULL;
}
std::vector<CVariant> valueList;
for (std::vector<int>::const_iterator itValue = values.begin(); itValue != values.end(); ++itValue)
valueList.push_back(CVariant(*itValue));
SettingPtrList settingValues;
if (!CSettingUtils::ValuesToList(setting, valueList, settingValues))
{
delete settingDefinition;
delete setting;
return NULL;
}
// setting the default will also set the actual value on an unchanged setting
setting->SetDefault(settingValues);
setting->SetControl(GetListControl("integer", false, heading, true));
setting->SetMinimumItems(minimumItems);
setting->SetMaximumItems(maximumItems);
setSettingDetails(setting, level, visible, help);
group->AddSetting(setting);
return setting;
}
void setCameraExposure()
{
int rv = system("v4l2-ctl -d /dev/video0 --set-ctrl exposure_auto=1");
usleep(1000000);
char buf2[128] = {0};
strcpy(buf2, "v4l2-ctl -d /dev/video0 --set-ctrl exposure_absolute=");
strcat(buf2, g_settings.getSettingText(CSetting::SETTING_EXPOSURE).c_str());
int rv2 = system(buf2);
usleep(1000000);
if (rv2 != 0)
{
printf("rv2 = %d, %s\n", rv2, buf2);
}
}
void CGUIControlRangeSetting::Update(bool updateDisplayOnly /* = false */)
{
if (m_pSlider == NULL ||
m_pSetting->GetType() != SettingTypeList)
return;
CGUIControlBaseSetting::Update();
CSettingList *settingList = static_cast<CSettingList*>(m_pSetting);
const SettingPtrList &settingListValues = settingList->GetValue();
if (settingListValues.size() != 2)
return;
const CSetting *listDefintion = settingList->GetDefinition();
const CSettingControlRange *controlRange = static_cast<const CSettingControlRange*>(m_pSetting->GetControl());
const std::string &controlFormat = controlRange->GetFormat();
std::string strText;
std::string strTextLower, strTextUpper;
std::string formatString = g_localizeStrings.Get(controlRange->GetFormatLabel() > -1 ? controlRange->GetFormatLabel() : 21469);
std::string valueFormat = controlRange->GetValueFormat();
if (controlRange->GetValueFormatLabel() > -1)
valueFormat = g_localizeStrings.Get(controlRange->GetValueFormatLabel());
switch (listDefintion->GetType())
{
case SettingTypeInteger:
{
int valueLower, valueUpper;
if (updateDisplayOnly)
{
valueLower = m_pSlider->GetIntValue(CGUISliderControl::RangeSelectorLower);
valueUpper = m_pSlider->GetIntValue(CGUISliderControl::RangeSelectorUpper);
}
else
{
valueLower = static_cast<CSettingInt*>(settingListValues[0].get())->GetValue();
valueUpper = static_cast<CSettingInt*>(settingListValues[1].get())->GetValue();
m_pSlider->SetIntValue(valueLower, CGUISliderControl::RangeSelectorLower);
m_pSlider->SetIntValue(valueUpper, CGUISliderControl::RangeSelectorUpper);
}
if (controlFormat == "date" || controlFormat == "time")
{
CDateTime dateLower = (time_t)valueLower;
CDateTime dateUpper = (time_t)valueUpper;
if (controlFormat == "date")
{
if (valueFormat.empty())
{
strTextLower = dateLower.GetAsLocalizedDate();
strTextUpper = dateUpper.GetAsLocalizedDate();
}
else
{
strTextLower = dateLower.GetAsLocalizedDate(valueFormat);
strTextUpper = dateUpper.GetAsLocalizedDate(valueFormat);
}
}
else
{
if (valueFormat.empty())
valueFormat = "mm:ss";
strTextLower = dateLower.GetAsLocalizedTime(valueFormat);
strTextUpper = dateUpper.GetAsLocalizedTime(valueFormat);
}
}
else
{
strTextLower = StringUtils::Format(valueFormat.c_str(), valueLower);
strTextUpper = StringUtils::Format(valueFormat.c_str(), valueUpper);
}
if (valueLower != valueUpper)
strText = StringUtils::Format(formatString.c_str(), strTextLower.c_str(), strTextUpper.c_str());
else
strText = strTextLower;
break;
}
case SettingTypeNumber:
{
double valueLower, valueUpper;
if (updateDisplayOnly)
{
valueLower = static_cast<double>(m_pSlider->GetFloatValue(CGUISliderControl::RangeSelectorLower));
valueUpper = static_cast<double>(m_pSlider->GetFloatValue(CGUISliderControl::RangeSelectorUpper));
}
else
{
valueLower = static_cast<CSettingNumber*>(settingListValues[0].get())->GetValue();
valueUpper = static_cast<CSettingNumber*>(settingListValues[1].get())->GetValue();
m_pSlider->SetFloatValue((float)valueLower, CGUISliderControl::RangeSelectorLower);
m_pSlider->SetFloatValue((float)valueUpper, CGUISliderControl::RangeSelectorUpper);
}
strTextLower = StringUtils::Format(valueFormat.c_str(), valueLower);
if (valueLower != valueUpper)
{
strTextUpper = StringUtils::Format(valueFormat.c_str(), valueUpper);
strText = StringUtils::Format(formatString.c_str(), strTextLower.c_str(), strTextUpper.c_str());
}
else
strText = strTextLower;
break;
}
default:
strText.clear();
break;
}
if (!strText.empty())
m_pSlider->SetTextValue(strText);
}
/******************************************************************************
Description.: this thread worker grabs a frame and copies it to the global buffer
Input Value.: unused
Return Value: unused, always NULL
******************************************************************************/
void *cam_thread(void *arg) {
g_settings.init();
setCameraExposure();
CVideoFrame* pFrame = NULL;
#ifndef TEST_USE_JPEGS_NOT_CAMERA
int width = VIEW_PIXEL_X_WIDTH;
int height = VIEW_PIXEL_Y_HEIGHT;
IplImage * img = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 3); // obraz OpenCV
#endif
frameGrinder.init();
#ifdef TEST_USE_JPEGS_NOT_CAMERA
std::string sBasePath = "/home/";
sBasePath += HOME_NAME;
std::string sPath = sBasePath;
sPath += "/0243-20150125-22-21-46.jpg";
//sPath += "/0007-20150125-22-36-25.jpg";
cv::Mat frame1 = cv::imread(sPath.c_str(), CV_LOAD_IMAGE_COLOR);
if (frame1.empty()) {
dbgMsg_s("Failed to read image data from a file1\n");
}
sPath = sBasePath;
sPath += "/0243-20150125-22-21-46.jpg";
//sPath += "/0007-20150125-22-36-25.jpg";
cv::Mat frame2 = cv::imread(sPath.c_str(), CV_LOAD_IMAGE_COLOR);
if (frame2.empty()) {
dbgMsg_s("Failed to read image data from a file2\n");
}
bool toggle = false;
#endif
context *pcontext = (context*) arg;
pglobal = pcontext->pglobal;
/* set cleanup handler to cleanup allocated ressources */
pthread_cleanup_push(cam_cleanup, pcontext);
while (!pglobal->stop) {
while (pcontext->videoIn->streamingState == STREAMING_PAUSED) {
usleep(1); // maybe not the best way so FIXME
}
#ifdef TEST_USE_JPEGS_NOT_CAMERA
if (frameGrinder.safeGetFreeFrame(&pFrame)) {
if (toggle) {
pFrame->m_frame = frame1;
} else {
pFrame->m_frame = frame2;
}
toggle = (!toggle);
if (!pFrame->m_frame.empty()) {
frameGrinder.safeAddTail(pFrame, CVideoFrame::FRAME_QUEUE_WAIT_FOR_BLOB_DETECT);
} else {
dbgMsg_s("Frame is empty\n");
frameGrinder.safeAddTail(pFrame, CVideoFrame::FRAME_QUEUE_FREE);
}
frameGrinder.m_testMonitor.m_nTasksDone[CTestMonitor::TASK_DONE_CAMERA]++;
}
#else
/* grab a frame */
if (uvcGrab(pcontext->videoIn) < 0) {
IPRINT("Error grabbing frames\n");
exit(EXIT_FAILURE);
}
DBG("received frame of size: %d from plugin: %d\n", pcontext->videoIn->buf.bytesused, pcontext->id);
/*
* Workaround for broken, corrupted frames:
* Under low light conditions corrupted frames may get captured.
* The good thing is such frames are quite small compared to the regular pictures.
* For example a VGA (640x480) webcam picture is normally >= 8kByte large,
* corrupted frames are smaller.
*/
if (pcontext->videoIn->buf.bytesused < minimum_size) {
DBG("dropping too small frame, assuming it as broken\n");
continue;
}
if (g_settings.isDynamicSettingsEnabled())
{
g_settings.getValueFromFile(CSetting::SETTING_EXPOSURE);
}
if(g_settings.isValueChanged(CSetting::SETTING_EXPOSURE))
{
setCameraExposure();
}
#ifdef NO_CV_JUST_STREAM_THE_CAMERA
/* copy JPG picture to global buffer */
pthread_mutex_lock(&pglobal->in[pcontext->id].db);
/*
* If capturing in YUV mode convert to JPEG now.
* This compression requires many CPU cycles, so try to avoid YUV format.
* Getting JPEGs straight from the webcam, is one of the major advantages of
* Linux-UVC compatible devices.
*/
if (pcontext->videoIn->formatIn == V4L2_PIX_FMT_YUYV) {
DBG("compressing frame from input: %d\n", (int) pcontext->id);
pglobal->in[pcontext->id].size = compress_yuyv_to_jpeg(pcontext->videoIn, pglobal->in[pcontext->id].buf, pcontext->videoIn->framesizeIn, gquality);
} else {
DBG("copying frame from input: %d\n", (int) pcontext->id);
pglobal->in[pcontext->id].size = memcpy_picture(pglobal->in[pcontext->id].buf, pcontext->videoIn->tmpbuffer, pcontext->videoIn->buf.bytesused);
}
/* copy this frame's timestamp to user space */
pglobal->in[pcontext->id].timestamp = pcontext->videoIn->buf.timestamp;
/* signal fresh_frame */
pthread_cond_broadcast(&pglobal->in[pcontext->id].db_update);
pthread_mutex_unlock(&pglobal->in[pcontext->id].db);
#else // #ifndef NO_CV_JUST_STREAM_THE_CAMERA
if (frameGrinder.safeGetFreeFrame(&pFrame)) {
std::vector<uchar> vectordata(pcontext->videoIn->tmpbuffer, pcontext->videoIn->tmpbuffer + (height * width));
cv::Mat data_mat(vectordata, false);
cv::Mat image(cv::imdecode(data_mat, 1)); //put 0 if you want greyscale
pFrame->m_frame = image;
if (!pFrame->m_frame.empty()) {
frameGrinder.safeAddTail(pFrame, CVideoFrame::FRAME_QUEUE_WAIT_FOR_BLOB_DETECT);
} else {
dbgMsg_s("Frame is empty\n");
frameGrinder.safeAddTail(pFrame, CVideoFrame::FRAME_QUEUE_FREE);
}
frameGrinder.m_testMonitor.m_nTasksDone[CTestMonitor::TASK_DONE_CAMERA]++;
}
#endif // #ifndef NO_CV_JUST_STREAM_THE_CAMERA
#endif // TEST_USE_JPEGS_NOT_CAMERA
}
DBG("leaving input thread, calling cleanup function now\n");
pthread_cleanup_pop(1);
return NULL;
}
void CUpperGoalDetector::detectBlobs(CVideoFrame * pFrame, CFrameGrinder* pFrameGrinder)
{
try
{
static struct timespec timeLastCameraFrame = {0};
static struct timespec timeNow = {0};
static cv::Scalar lowerBounds = cv::Scalar(79,0,150);
static cv::Scalar upperBounds = cv::Scalar(96,255,250);
cv::Mat img_hsv, img_blur, goal_blob;
static int iCount = 0;
int timeSinceLastCameraFrameMilliseconds = (int) CTestMonitor::getDeltaTimeMilliseconds(
timeLastCameraFrame,
pFrame->m_timeAddedToQueue[(int) CVideoFrame::FRAME_QUEUE_WAIT_FOR_BLOB_DETECT]);
timeLastCameraFrame = pFrame->m_timeAddedToQueue[(int) CVideoFrame::FRAME_QUEUE_WAIT_FOR_BLOB_DETECT];
// RBG is flawed as a way to filter based on color because the brightness is combined
// with the color info.
// Not so with HSV, where Hue and Saturation are maintained separately
// OpenCV has a handy conversion from RGB to HSV
cv::cvtColor(pFrame->m_frame, img_hsv, CV_BGR2HSV);
cv::GaussianBlur(img_hsv, img_blur, cv::Size(5,5),1.5);
// Look for the green hue we are emitting from the LED halo
if(g_settings.isDynamicSettingsEnabled())
{
g_settings.getValueFromFile(CSetting::SETTING_FILTER_HUE_LOWER_BOUND);
g_settings.getValueFromFile(CSetting::SETTING_FILTER_HUE_UPPER_BOUND);
}
if(g_settings.isValueChanged(CSetting::SETTING_FILTER_HUE_LOWER_BOUND))
{
lowerBounds = cv::Scalar(g_settings.getSetting(CSetting::SETTING_FILTER_HUE_LOWER_BOUND),0,150);
}
if(g_settings.isValueChanged(CSetting::SETTING_FILTER_HUE_UPPER_BOUND))
{
upperBounds = cv::Scalar(g_settings.getSetting(CSetting::SETTING_FILTER_HUE_UPPER_BOUND),255,250);
}
// Find the bright response from the retro-reflective tape
cv::inRange(img_blur, lowerBounds, upperBounds, goal_blob);
pFrame->m_filteredFrame = goal_blob.clone();
iCount++;
if ((iCount % 17) == 0)
{
pFrameGrinder->m_testMonitor.saveFrameToJpeg(pFrame->m_filteredFrame);
}
//Find the contours. Use the contourOutput Mat so the original image doesn't get overwritten
cv::vector<std::vector<cv::Point> > goalContours;
cv::findContours(goal_blob, goalContours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);
CUpperGoalRectangle upperGoalRectangle;
float upperGoalAzimuthDegrees = 0.0;
float distanceToUpperGoalInches = 0.0;
bool isUpperGoalFound = false;
isUpperGoalFound = filterContours(goalContours, pFrame->m_frame.rows, pFrame->m_frame.cols,
upperGoalRectangle, upperGoalAzimuthDegrees, distanceToUpperGoalInches);
CTestMonitor::getTicks(&timeNow);
int timeLatencyThisCameraFrameMilliseconds = (int) CTestMonitor::getDeltaTimeMilliseconds(
pFrame->m_timeAddedToQueue[(int) CVideoFrame::FRAME_QUEUE_WAIT_FOR_BLOB_DETECT],
timeNow);
pFrame->m_targetInfo.updateTargetInfo(
timeSinceLastCameraFrameMilliseconds, timeLatencyThisCameraFrameMilliseconds,
isUpperGoalFound, upperGoalAzimuthDegrees, distanceToUpperGoalInches, upperGoalRectangle.center.x);
pFrame->updateAnnotationInfo(upperGoalRectangle);
m_gpioLed.setGreenLED(isUpperGoalFound, pFrame->m_timeRemovedFromQueue[(int) CVideoFrame::FRAME_QUEUE_WAIT_FOR_BLOB_DETECT]);
}
catch (...)
{
}
}
