int ImgDataTEST::T_getWidth() {
int fail = 0;
logger->trace("==============================");
logger->trace("Testing getWidth():");
logger->trace(" Init 10x2 Mat obj...");
cv::Mat img = cv::Mat::eye(10,2,CV_32F);
logger->trace(" Creating ImgData obj...");
ImgData* data = new ImgData("data",img);
logger->trace(" Using getWidth()...");
logger->trace(" "+StringTools::intToStr(data->getWidth()));
if (data->getWidth() == 2)
logger->trace(" ok");
else {
logger->warn(" NOT ok, width incorrect");
fail += 1;
}
logger->trace("Test complete.");
logger->trace("Deleting data...");
delete data;
if (fail > 0)
logger->warn(" TEST FAILED: getWidth()");
logger->trace("==============================");
return fail;
}
std::vector<cv::Point2f> ShapeFilter::findMassCenter(Data *data){
// check for whether the input is of the correct type. From Albert
ImgData* imgData = dynamic_cast<ImgData*>(data);
if (imgData == 0) {
std::vector<cv::Point2f> bad;
return bad;
}
return findMassCenter(imgData->getImg());
}
int FilterManagerTEST::T_applyFilterChain() {
int fail = 0;
logger->trace("==============================");
logger->trace("Testing applyFilterChain():");
logger->trace(" Creating FM under normal mode...");
FilterManager* fm = new FilterManager("fm");
logger->trace(" Using factory, making 4 random filters...");
Filter* f1,*f2,*f3,*f4;
f1 = FilterFactory::createFilter();
f2 = FilterFactory::createNullImgFilter();
f3 = FilterFactory::createNullFPGAFilter();
f4 = FilterFactory::createFilter();
logger->trace(" Inserting f1 as \"task 3\" to FRONT...");
fm->insertFilter("task 3",f1,"FRONT");
logger->trace(" Inserting f2 as \"task 1\"...");
fm->insertFilter("task 1",f2,"task 3");
logger->trace(" Inserting f3 as \"task 2\" between f1,f2...");
fm->insertFilter("task 2",f3,"task 3");
logger->trace(" Inserting f4 as \"task 4\" to REAR...");
fm->insertFilter("task 4",f4);
logger->trace(" Making img objs...");
cv::Mat img = cv::Mat::zeros(2,2,CV_8UC1);
ImgData* data = new ImgData("input",img);
logger->trace(" Applying all filters...");
int res = fm->applyFilterChain(data);
logger->trace(" Checking data ID...");
logger->trace(" "+data->getID());
if (data->getID() == "fm")
logger->trace(" ok");
else {
logger->warn(" NOT ok, ID not set!");
fail++;
}
logger->trace(" "+data->getTrack()+"error code "+std::to_string(res));
if (data->getTrack() == "task 1; task 2-1; task 3; task 4; ")
if (res == 1)
logger->trace(" ok");
else {
logger->warn(" NOT ok, error code incorrect");
}
else {
logger->warn(" NOT ok, track record not expected");
}
img.release();
delete data;
delete fm;
logger->trace("Testing complete.");
if (fail > 0)
logger->warn(" TEST FAILED: applyFilterChain");
logger->trace("==============================");
return fail;
}
int ImgDataTEST::T_Constructor() {
int fail = 0;
logger->trace("==============================");
logger->trace("Testing Constructor:");
logger->trace(" Init Mat obj using camCap()...");
logger->trace(" Showing capped img...");
cv::Mat img = ImgDataTEST::camCap();
logger->trace(" Constructing new ImgData obj with arg \"data\" and Mat obj...");
ImgData* data = new ImgData("data", img);
logger->trace(" Complete.");
logger->trace(" Checking initialized variables...");
logger->trace(" Using getID()...");
if (data->getID() == "data")
logger->trace(" ok");
else {
logger->warn(" NOT ok, ID initialization incorrect");
fail += 1;
}
logger->trace(" Using showImg()...");
logger->trace(" If both imgs are identical press spacebar, else press esc...");
data->showImg();
char key;
while (1) {
key = cvWaitKey(0);
if (char(key) == 32) {
logger->trace(" ok");
break;
}
else if (char(key) == 27) {
logger->warn(" NOT ok, img not same");
fail++;
break;
}
}
// logger->trace(" Using getImg() and comparing...");
//TODO
logger->trace("Test complete.");
logger->trace("Closing windows...");
data->closeImg();
cvDestroyWindow("camCap");
logger->trace("Deleting data...");
delete data;
if (fail > 0)
logger->warn(" TEST FAILED: Data Constructor");
logger->trace("==============================");
return fail;
}
//--------------------------------------------------------------
void ContentElement::setElemTranslation(float x, float y, float z) throw (runtime_error) {
float offX = 0, offY = 0, offZ = 0;
if (typeData != NULL) {
if (type == VID) {
VidData* vidElem = (VidData*)typeData;
offX = - (vidElem->getWidth() / 2) * elemScale;
offY = - (vidElem->getHeight() / 2) * elemScale;
} else if (type == IMG) {
ImgData* imgElem = (ImgData*)typeData;
offX = - (imgElem->getWidth() / 2) * elemScale;
offY = - (imgElem->getHeight() / 2) * elemScale;
}
} else {
throw runtime_error("Set type data object before element translation.");
}
elemTrans[0] = x + offX;
elemTrans[1] = y + offY;
elemTrans[2] = z + offZ;
}
bool ShapeFilter::filter(Data *data){
// check for whether the input is of the correct type. From Albert
ImgData* imgData = dynamic_cast<ImgData*>(data);
if (imgData == 0) {
// track the error and return error
this->track(data,this->filterID,1,1);
return false;
}
//beging filtering process
if (shape == 1){ ///rectangle
return this->findRect((imgData->getImg())); //lazy to copy+paste everything
}else if (shape == 2){ ///circle
return this->findCirc(imgData->getImg());
}
//ending filtering process
//track and return
this->track(imgData, this->filterID, 0,0);
return true;
}
int ImgDataTEST::T_cpConstructor() {
int fail = 0;
logger->trace("==============================");
logger->trace("Testing Copy Constructor:");
logger->trace(" Using camCap() to get Mat obj...");
cv::Mat img = ImgDataTEST::camCap();
cvDestroyWindow("camCap");
logger->trace(" Constructing new ImgData obj with arg \"data\" and Mat obj...");
ImgData* data = new ImgData("data",img);
logger->trace(" Setting Msg to \"SubZero rox\"...");
data->setMsg("SubZero rox");
logger->trace(" Invoking Copy Constructor...");
ImgData* copy = new ImgData(*data);
logger->trace(" Checking variables...");
logger->trace(" Using getID()...");
if (copy->getID() == "data")
logger->trace(" ok");
else {
logger->warn(" NOT ok, ID copy incorrect");
fail += 1;
}
logger->trace(" Using getMsg()...");
if (copy->getMsg() == "SubZero rox")
logger->trace(" ok");
else {
logger->warn(" NOT ok, Msg copy incorrect");
fail += 1;
}
logger->trace(" Showing imgs using showImg()...");
logger->trace(" If both imgs are identical press spacebar, else press esc...");
data->showImg("data");
copy->showImg("copy");
char key;
while (1) {
key = cvWaitKey(0);
if (char(key) == 32) {
logger->trace(" ok");
break;
}
else if (char(key) == 27) {
logger->warn(" NOT ok, img not same");
fail++;
break;
}
}
logger->trace(" Changing msg of copy to \"whatever\"...");
copy->setMsg("whatever");
// logger->trace(" Changing org img content...");
// data->closeImg();
// copy->closeImg();
// img = ImgDataTEST::camCap();
// cvDestroyWindow("camCap");
// data->setImg(&img);
logger->trace(" Checking variables...");
logger->trace(" Using getMsg() on original...");
if (copy->getMsg() == "whatever" && data->getMsg() == "SubZero rox")
logger->trace(" ok");
else {
logger->warn(" NOT ok, org or copy Msg incorrect");
fail += 1;
}
logger->trace(" Using refcount to check independence...");
int datarc, copyrc;
datarc = data->img.u->refcount;
copyrc = copy->img.u->refcount;
logger->trace(" \"data\" img refcount: "+StringTools::intToStr(datarc));
logger->trace(" \"copy\" img refcount: "+StringTools::intToStr(copyrc));
if (datarc==2 && copyrc ==1) {
logger->trace(" ok");
fail--;
}
else if (datarc==3)
logger->warn(" NOT ok, copy's img points to data's img obj");
else
logger->warn(" NOT ok, data ref should be 2, copy ref should be 1");
fail++;
// logger->trace(" Showing imgs using showImg()...");
// data->showImg("data");
// copy->showImg("copy");
// logger->trace(" If copy different from data then deep copy ok press spacebar, else press esc...");
// while (1) {
// key = cvWaitKey(0);
// if (char(key) == 32) {
// logger->trace(" ok");
// break;
// }
// else if (char(key) == 27) {
// logger->warn(" NOT ok, img not same");
// fail++;
// break;
// }
// }
logger->trace("Test complete.");
logger->trace("Deleting data...");
delete data;
delete copy;
if (fail > 0)
logger->warn(" TEST FAILED: ImgData Copy Constructor");
logger->trace("==============================");
return fail;
}
int ImgDataTEST::T_setImg() {
int fail = 0;
logger->trace("==============================");
logger->trace("Testing setImg():");
logger->trace(" Creating 2 Mat obj using camCap()...");
cv::Mat test = camCap();
cvDestroyWindow("camCap");
cv::Mat test2 = camCap();
cvDestroyWindow("camCap");
cv::namedWindow("obj 1");
cv::imshow("obj 1",test);
cv::namedWindow("obj 2");
cv::imshow("obj 2",test2);
logger->trace(" Accessing refcount...");
int t1rc,t2rc,imgrc;
t1rc = test.u->refcount;
t2rc = test2.u->refcount;
logger->trace(" Obj 1 refcount: "+StringTools::intToStr(t1rc));
logger->trace(" Obj 2 refcount: "+StringTools::intToStr(t2rc));
if (t1rc+t2rc==2)
logger->trace(" ok");
else {
logger->warn(" NOT ok, refcount should be 1 for both");
fail++;
}
logger->trace(" Creating ImgData with obj 1...");
ImgData* testImg = new ImgData("plswork", test);
logger->trace(" Accessing refcount...");
t1rc = test.u->refcount;
t2rc = test2.u->refcount;
imgrc = testImg->img.u->refcount;
logger->trace(" Obj 1 refcount: "+StringTools::intToStr(t1rc));
logger->trace(" Obj 2 refcount: "+StringTools::intToStr(t2rc));
if (t1rc == 2) {
if (imgrc == 2) {
if(t2rc == 1)
logger->trace(" ok");
else {
logger->warn(" NOT ok, obj 2 refcount should be 1");
fail++;
}
}
else {
logger->warn(" NOT ok, obj 1 refcount disagree");
fail++;
}
} else {
logger->warn(" NOT ok, obj 1 refcount should be 2");
fail++;
}
logger->trace(" Try showImg(), expect photo to be as same as obj 1...");
logger->trace(" If true, hit space, else hit esc...");
testImg->showImg();
char key;
while (1) {
key = cvWaitKey(0);
if (char(key) == 32) {
logger->trace(" ok");
break;
}
else if (char(key) == 27) {
logger->warn(" NOT ok, img not expected");
fail++;
break;
}
}
logger->trace(" Setting obj 2 to img...");
testImg->setImg(test2);
logger->trace(" Accessing refcount...");
t1rc = test.u->refcount;
t2rc = test2.u->refcount;
logger->trace(" Obj 1 refcount: "+StringTools::intToStr(t1rc));
logger->trace(" Obj 2 refcount: "+StringTools::intToStr(t2rc));
if (t1rc==1 && t2rc==2)
logger->trace(" ok");
else {
logger->warn(" NOT ok, refcount should be 1 for obj 1 and 2 for obj 2");
fail++;
}
logger->trace(" Release obj 2 from outside ImgData...");
test2.release();
logger->trace(" Try showImg(), expect photo to be as same as obj 2...");
testImg->showImg();
logger->trace(" If true, hit space, else hit esc...");
while (1) {
key = cvWaitKey(0);
if (char(key) == 32) {
logger->trace(" ok");
break;
}
else if (char(key) == 27) {
logger->warn(" NOT ok, img not expected");
fail++;
break;
}
}
logger->trace(" Accessing refcount...");
t1rc = test.u->refcount;
imgrc = testImg->img.u->refcount;
logger->trace(" Obj 1 refcount: "+StringTools::intToStr(t1rc));
logger->trace(" Obj 2 refcount: "+StringTools::intToStr(imgrc));
if (t1rc+imgrc==2)
logger->trace(" ok");
else {
logger->warn(" NOT ok, refcount should be 1 for both");
fail++;
}
logger->trace(" Deleting ImgData...");
delete testImg;
logger->trace(" Release obj 1...");
test.release();
cv::destroyWindow("obj 1");
cv::destroyWindow("obj 2");
if (fail > 0)
logger->warn(" TEST FAILED: setImg()");
logger->trace("==============================");
return fail;
}
int RGBFilterTEST::T_filter() {
int fail = 0;
logger->trace("==============================");
logger->trace("Testing filter():");
// logger->trace(" Using imread...");
// cv::Mat img = cv::imread("rgb_mode_0.jpg",CV_LOAD_IMAGE_COLOR);
// if (! img.data)
// logger->warn(" OH NO, img not read");
logger->trace(" Using camCap...");
ImgDataTEST* imgTest = new ImgDataTEST();
cv::Mat img = imgTest->camCap();
cvDestroyWindow("camCap");
logger->trace(" Loading test image into a ImgData wrapper...");
ImgData* testImg = new ImgData("raw",img);
logger->trace(" Copying ImgData to second wrapper...");
ImgData* testImg2 = new ImgData(*testImg);
logger->trace(" Showing one copy of test image (should be named \"raw\")...");
testImg->showImg();
logger->trace(" Filtering first data w/ full luminosity specturm, aka mode 0...");
logger->trace(" Init int arr[3]...");
int arr[] = {25,-15,-20};
logger->trace(" Using filter factory, create mode 0 filter...");
RGBFilter* rgbFilter = new RGBFilter(arr);//(RGBFilter*)FilterFactory::createRGBFilter(arr);
logger->trace(" Creating filter manager w/ id \"RGBFilter MODE 0\"...");
FilterManager* fm = new FilterManager("RGBFilter MODE 0");
logger->trace(" Inserting filter as \"rgb mode 0\"...");
fm->insertFilter("rgb mode 0",rgbFilter);
logger->trace(" Attempt filtering using filter manager...");
fm->applyFilterChain(testImg);
logger->trace(" Showing filtered test image...");
testImg->showImg();
logger->trace(" Expect 2 windows, \"raw\" and \"RGBFilter MODE 0\", the latter should be red shifted");
logger->trace(" If true, hit space, else hit esc");
char key;
while (1) {
key = cvWaitKey(0);
if (char(key) == 32) {
logger->trace(" ok");
break;
}
else if (char(key) == 27) {
logger->warn(" NOT ok, details of output under mode 0 not correct");
fail++;
break;
}
}
logger->trace(" Filtering data 2 w/ 3 zones of luminosity separately, aka mode 1...");
logger->trace(" Init int high[3],mid[3],shad[3]...");
int high[] = {255,255,255};
int mid[] = {50,-30,-30};
int shad[] = {-255,-255,-255};
logger->trace(" Using filter factory, create mode 1 filter...");
RGBFilter* rgbFilter2 = new RGBFilter(high,mid,shad);//(RGBFilter*)FilterFactory::createRGBFilter(high,mid,shad);
logger->trace(" Creating filter manager w/ id \"RGBFilter MODE 1\"...");
FilterManager* fm2 = new FilterManager("RGBFilter MODE 1");
logger->trace(" Inserting filter as \"rgb mode 1\"...");
fm2->insertFilter("rgb mode 1",rgbFilter2);
logger->trace(" Attempt filtering using filter manager...");
fm2->applyFilterChain(testImg2);
logger->trace(" Showing filtered test image...");
testImg2->showImg();
logger->trace(" Expect 3 windows in total, \"raw\" and \"RGBFilter MODE 0\" and \"RGBFilter MODE 1\", the latter should be red shifted, but a bit differently");
logger->trace(" If true, hit space, else hit esc");
while (1) {
key = cvWaitKey(0);
if (char(key) == 32) {
logger->trace(" ok");
break;
}
else if (char(key) == 27) {
logger->warn(" NOT ok, details of output under mode 1 not correct");
fail++;
break;
}
}
delete fm;
delete fm2;
cvDestroyWindow("raw");
testImg->closeImg();
testImg2->closeImg();
delete testImg;
delete testImg2;
img.release();
if (fail > 0)
logger->warn(" TEST FAILED: filter()");
logger->trace("==============================");
return fail;
}
void BuoyTask::execute() {
HSVFilter green(std::stoi(settings->getProperty("g1")),
std::stoi(settings->getProperty("g2")),
std::stoi(settings->getProperty("g3")),
std::stoi(settings->getProperty("g4")),
std::stoi(settings->getProperty("g5")),
std::stoi(settings->getProperty("g6")));
HSVFilter red(std::stoi(settings->getProperty("r1")),
std::stoi(settings->getProperty("r2")),
std::stoi(settings->getProperty("r3")),
std::stoi(settings->getProperty("r4")),
std::stoi(settings->getProperty("r5")),
std::stoi(settings->getProperty("r6")));
//only look for 1 circle
ShapeFilter sf (2, 1);
//assuming the sub is in the correct position
//first look for red, and then hit it
//then look and hit green
bool hitGreen = false;
bool hitRed = false;
int retreat = 0;
int moveDist = std::stoi(settings->getProperty("moveDist"));
int rotateAng = std::stoi(settings->getProperty("rotateAng"));
int movementDelay = std::stoi(settings->getProperty("movementDelay"));
int deltaDist = 0;
float deltaT = 0;
bool done = false;
while (!done) {
std::string s = "raw";
ImgData* data = dynamic_cast<ImgData*>
(dynamic_cast<CameraState*>
(camModel->getState())->getDeepState(s));
imgWidth = data->getImg().size().width;
imgHeight = data->getImg().size().height;
// cv::imshow("hsv",data->getImg());
//filter for a color depending if the other color is hit or not
if (!hitRed){
println("Filtering red");
red.filter(data);
} else if (!hitGreen){
//println("Filtering green");
//green.filter(data);
done = true;
continue;
} else if (hitGreen && hitRed) {
done = true;
println("Done task");
continue;
}
//after hitting a color, move the sub back to look for the other one
//TODO: CALIBRATE THIS STEP
if (sf.filter(data)){
retreat = false;
cv::Point2f cent = sf.getCenter()[0];
if (std::abs(cent.x - imgWidth/2) < imgWidth/20){
//in the middle 20% of the screen horizontally
if (std::abs(cent.y - imgHeight / 2) < imgHeight / 20) {
//in the middle 20% vertically
float d = calcDistance(sf.getRad()[0]) * 1.2;
float t = d/moveSpeed;
println("Moving " + std::to_string(d) + "cm in " + std::to_string(t) + "s");
move(moveSpeed);
usleep(std::stoi(settings->getProperty("MOVE_TIME")));
if (!hitRed){
hitRed = true;
println("Hit red");
retreat = true;
} else {
hitGreen = true;
println("Hit green");
retreat = true;
}
logger->info("Stopping");
move(0);
/*
//if the radius of the circle is huge, so the sub will hit it
if (sf.getRad()[0] > imgWidth*imgHeight/3){
if (!hitGreen){
hitGreen = true;
println("Hit green");
}else{
hitRed = true;
println("Hit red");
}
//return the sub back to its orginal position
move(0);
retreat = true;
println("Retreat enabled");
}else{
//move straight and hit it
float dist = calcDistance(sf.getRad()[0]);
deltaDist = dist*1.2;
println("Moving forward " + std::to_string(deltaDist) + "cm to hit buoy");
move(deltaDist);
}*/
} else {
float deltaY;
if (cent.y > imgHeight/2) {
deltaY = -0.1; //rise a bit
} else {
deltaY = 0.1; //sink a bit
}
//float deltaY = (cent.y - imgHeight/2)/sf.getRad()[0];
println("Rising " + std::to_string(deltaY*100)+"cm");
changeDepth(deltaY);
}
} else {
println("Center: " + std::to_string(cent.x) + " " + std::to_string(imgWidth/2));
//float ang = atan2(cent.x-imgWidth/2, 0) * 180 / M_PI;
//float dX = cent.x-imgWidth/2;
//dX * 23/sf.getRad()[0];
//float ang = atan(dX/calcDistance(sf.getRad()[0])) * 180 / M_PI;
//println("Rotating " + std::to_string(ang) + " degrees");
//rotate(ang);
float dir = cent.x-imgWidth/2;
println("Rotating 10 degrees " + std::to_string(dir));
dir /= std::abs(dir);
rotate (5*dir);
/*
float scale = 23/sf.getRad()[0];
float dist = sf.getCenter()[0].x - imgWidth/2;
//slide 2/3 of the way
float deltaX = dist*scale/3*2;
println("Sliding " + std::to_string(deltaX)+"cm");
slide(deltaX);*/
}
} else {
///CIRCLES NOT FOUND
///ROTATE/MOVE SUB
//rotate(rotateAng);
println("Circle not found, moving forward");
//move(moveDist);
if (retreat) {
if (moveWithSpeed){
println("Retreating");
move(-moveSpeed);
usleep(40000000);
//usleep(deltaT * 500);
move(0);
rotate(-deltaAngle);
usleep(5000000);
} else {
println("Retreating " + std::to_string(-deltaDist - 20) + "cm");
move(-deltaDist - 20); //move 20cm more than i needed
//sleep(movementDelay);
//move the sub back to the middle
if (deltaAngle != -1){
println("Retreat rotating " + std::to_string(deltaAngle) + " degrees");
rotate(deltaAngle);
println("Retreat to middle by " + std::to_string(deltaDist-20) + "cm");
move (deltaDist-20); //move 20cm less than i need
rotate(-deltaAngle);
}
}
retreat = false;
// continue;
} else {
///tries to look for any colors and move towards it
logger->info("Looking for coloured masses to turn towards");
std::vector<cv::Point2f> mc = sf.findMassCenter(data);
if (mc.size() > 0) {
logger->info("Found coloured mass");
float dir = mc[0].x - imgWidth/2;
dir /= std::abs(dir);
rotate(5 * dir);
} else {
///if it dosnt see any colors, move forwards
logger->debug("No coloured masses found. Moving forward");
move(moveSpeed);
}
}
}
delete data;
data = 0;
usleep(33000);
}
}
bool LineFilter::filter(Data *data){
// check for whether the input is of the correct type. From Albert
ImgData* imgData = dynamic_cast<ImgData*>(data);
if (imgData == 0) {
// track the error and return error
this->track(data,this->filterID,1,1);
return false;
}
cv::imshow("asdf", filter(imgData->getImg().clone(),0));
//begin filter sequence
int linesFound = 0;
cv::Mat src = imgData->getImg();
cv::Mat dst;
cv::Mat cdst = src.clone();
Canny(src, dst, 50, 200, 3);
cvtColor(dst, cdst, CV_GRAY2BGR);
std::vector<cv::Vec2f> lines;
//detects lines
HoughLines(dst, lines, 1, CV_PI/180, 100, 0, 0 );
//ending filter sequence
//calculating the line equation
linesEq.clear();
float x1 = 0, x2 = 0, y1 = 0, y2 = 0;
for( size_t i = 0; i < lines.size(); i++ ){
float rho = lines[i][0], theta = lines[i][1];
cv::Point pt1, pt2;
double a = cos(theta), b = sin(theta);
double x0 = a*rho, y0 = b*rho;
pt1.x = cvRound(x0 + 1000*(-b));
pt1.y = cvRound(y0 + 1000*(a));
pt2.x = cvRound(x0 - 1000*(-b));
pt2.y = cvRound(y0 - 1000*(a));
x1 = pt1.x;
y1 = pt1.y;
x2 = pt2.x;
y2 = pt2.y;
//equation of line
std::vector<float> eq;
//y = mx+b
//B MIGHT BE USELSES, NEED FURTHER TESTING
bool safeMath = true;
float M = 0, B = 0;
if (x2-x1 < 5){ //straight line
safeMath = false;
M = INFINITY;
B = INFINITY;
}
if (safeMath){ //avoid div by 0 error
//M = (y2-y1) / (x2-x1);
double realtheta = (rho < 0)? theta - M_PI:theta;
realtheta = -realtheta + M_PI/2;
M = tan(realtheta);
B = y2 - M*x2;
}
bool repeat = false;
//check if there is a similar line already
for (std::vector<float> lines: linesEq){
//vert line situations
if (M == INFINITY && lines[0] == INFINITY){
//check their x values
if (std::abs(lines[2] - ((x1+x2)/2)) < maxDiff){
repeat = true;
break;
}
}
//check if m is almost vertical
else if (std::abs(M) > maxSlope && lines[0] == INFINITY){
//std::cout<<"almost vert ";
//std::cout<<std::abs(lines[2] - ((x1+x2)/2))<<std::endl;
if (std::abs(lines[2] - ((x1+x2)/2) ) < maxDiff){
repeat = true;
break;
}
}
else if (M == INFINITY && std::abs(lines[0])> maxSlope){
//std::cout<<"almost vert II ";
//std::cout<<std::abs(lines[2] - ((x1+x2)/2))<<std::endl;
if (std::abs(lines[2] - ((x1+x2)/2) ) < maxDiff){
repeat = true;
break;
}
}
//check if m is too similar or not, b is too different to check
else if (std::abs(lines[0] - M) < maxDiff){
if (M > 15){ //vertical lines
//check if the intersection point is near the average x
if (std::abs((B-lines[1])/(lines[0]-M))-(x1+x2)/2 < maxDiff){
repeat = true;
break;
}
}else{ //horziontal lines
if (std::abs((B-lines[1])/(lines[0]-M))*M - (y1+y2)/2 < maxDiff){
repeat = true;
break;
}
}
}
}
if (!repeat){
eq.push_back(M);
eq.push_back(B);
//std::cout<<M<<" "<<B<<" " << ((x1+x2)/2) << " ";
if (std::abs(M) < 5){ //aprox horizontal line
eq.push_back(y2); //give it the y value
//std::cout<<y2;
//printf(" horz line");
}
if (std::abs(M) > maxSlope){ //vertical line
eq.push_back(x2); //x value
//std::cout<<x2;
//printf(" vertal line");
}
//std::cout<<std::endl;
linesEq.push_back(eq);
linesFound++;
//line(*cdst, pt1, pt2, cv::Scalar(0,0,255), 3, CV_AA); //drawing the line
}
}
//should i set imgData to something?? -Carl
//track and return
this->track(imgData, this->filterID, 0,0);
//println(linesFound != 0);
return linesFound != 0;
}
bool RGBFilter::filter(Data* data) {
// check for whether the input is of the correct type.
ImgData* cast = dynamic_cast<ImgData*>(data);
if (cast == 0) {
// track the error and return error
this->track(data,this->filterID,1,1);
return false;
}
if (cast->img.type() != 16) {
this->track(data,this->filterID,2,1);
return false;
}
// begin filter sequence.
int newPixelVal;
cv::Mat src = cast->getImg();
cv::Mat filteredImg = src.clone();
cv::Mat BGR[3];
cv::split(filteredImg,BGR);
// catch error?
// Full spectrum mode
if(this->mode == 0) {
for(int y = 0; y < src.cols; y++ ) {
for(int x = 0; x < src.rows; x++ ) {
for(int c = 0; c < 3; c++) {
newPixelVal = std::max(0,std::min(mxColour,BGR[c].at<unsigned char>(x,y) + midMult[c]*midtone[c]));
BGR[c].at<unsigned char>(x,y) = newPixelVal;
}
}
}
}
// 3 zone mode
if (this->mode == 1) {
int luminosity;
const int SHADTHRESHOLD = (int) mxColour*10/3;
const int HIGHTHRESHOLD = SHADTHRESHOLD * 2;
// get luminosity with some function
// use luminosity as a switch for case using high, mid or shad
for(int y = 0; y < src.cols; y++ ) {
for(int x = 0; x < src.rows; x++ ) {
// From 11%,59%,30% bgr respectively. Scaled to 1:6:3 factors
// luminosity range is from 0-2550, 1/3 is 850. Calc this from:
// 10*255, 10* MXCOLOR
luminosity = BGR[0].at<unsigned char>(x,y)*1+BGR[1].at<unsigned char>(x,y)*6+BGR[2].at<unsigned char>(x,y)*3;
for(int c = 0; c < 3; c++) {
if (luminosity < SHADTHRESHOLD)
newPixelVal = std::max(0,std::min(mxColour,BGR[c].at<unsigned char>(x,y) + shadMult[c]*shadow[c]));
else if (luminosity > HIGHTHRESHOLD)
newPixelVal = std::max(0,std::min(mxColour,BGR[c].at<unsigned char>(x,y) + highMult[c]*highlight[c]));
else
newPixelVal = std::max(0,std::min(mxColour,BGR[c].at<unsigned char>(x,y) + midMult[c]*midtone[c]));
BGR[c].at<unsigned char>(x,y) = newPixelVal;
}
}
}
}
//joining seq
cv::merge(BGR,3,filteredImg);
//set sequence
cast->setImg(filteredImg);
// end sequence.
// track and return
this->track(cast,this->filterID,0,0);
return true;
}
