void operator()(const Point2D& p) {
GNode n = g.createNode(0);
g.addNode(n);
nodes[p.x() * height + p.y()] = n;
}
bool mitk::PlanarDoubleEllipse::SetControlPoint(unsigned int index, const Point2D& point, bool createIfDoesNotExist)
{
switch (index)
{
case 0:
{
Point2D centerPoint = this->GetControlPoint(0);
Vector2D vector = point - centerPoint;
Superclass::SetControlPoint(0, point, createIfDoesNotExist);
Superclass::SetControlPoint(1, this->GetControlPoint(1) + vector, createIfDoesNotExist);
Superclass::SetControlPoint(2, this->GetControlPoint(2) + vector, createIfDoesNotExist);
Superclass::SetControlPoint(3, this->GetControlPoint(3) + vector, createIfDoesNotExist);
break;
}
case 1:
{
Vector2D vector = point - this->GetControlPoint(1);
Superclass::SetControlPoint(1, point, createIfDoesNotExist);
Point2D centerPoint = this->GetControlPoint(0);
Vector2D outerMajorVector = point - centerPoint;
Vector2D outerMinorVector;
outerMinorVector[0] = outerMajorVector[1];
outerMinorVector[1] = -outerMajorVector[0];
if (!m_ConstrainCircle)
{
outerMinorVector.Normalize();
outerMinorVector *= centerPoint.EuclideanDistanceTo(this->GetControlPoint(2));
}
Superclass::SetControlPoint(2, centerPoint + outerMinorVector, createIfDoesNotExist);
Vector2D innerMajorVector = outerMajorVector;
if (!m_ConstrainThickness)
{
innerMajorVector.Normalize();
innerMajorVector *= centerPoint.EuclideanDistanceTo(this->GetControlPoint(3) - vector);
}
Superclass::SetControlPoint(3, centerPoint - innerMajorVector, createIfDoesNotExist);
break;
}
case 2:
{
m_ConstrainCircle = false;
Superclass::SetControlPoint(2, point, createIfDoesNotExist);
break;
}
case 3:
{
m_ConstrainThickness = false;
Superclass::SetControlPoint(3, point, createIfDoesNotExist);
break;
}
default:
return false;
}
return true;
}
bool StudentLocalization::stepFindExactEyes(const IntensityImage &image, FeatureMap &features) const {
int temp = 0;
ImageIO::saveIntensityImage(image, ImageIO::getDebugFileName("input.png"));
IntensityImageStudent copy(image);
double** d_kern = new double*[3];
for (int y = 0; y < 3; y++) {
d_kern[y] = new double[3];
}
d_kern[0][0] = 0;
d_kern[0][1] = 1;
d_kern[0][2] = 0;
d_kern[1][0] = 1;
d_kern[1][1] = 0;
d_kern[1][2] = 1;
d_kern[2][0] = 0;
d_kern[2][1] = 1;
d_kern[2][2] = 0;
StudentKernel dilation = StudentKernel(d_kern, 3, 3, 0);
Feature top = features.getFeature(Feature::FEATURE_HEAD_TOP);
Feature bottom = features.getFeature(Feature::FEATURE_CHIN);
Feature nose_bottom = features.getFeature(Feature::FEATURE_NOSE_BOTTOM);
Feature headsideleft = features.getFeature(Feature::FEATURE_HEAD_LEFT_SIDE);
Feature headsideright = features.getFeature(Feature::FEATURE_HEAD_RIGHT_SIDE);
const int nose_to_top = nose_bottom.getY() - top.getY();
#if UNNECESSARY_CODE
#endif
Point2D<double> headsidelp = headsideleft.getPoints()[0];
headsidelp.setY(top.getY() + (nose_to_top*3/5));
headsidelp.setX((headsidelp.getX()));
Point2D<double> headsiderp = headsideright.getPoints()[0];
headsiderp.setY(nose_bottom.getY() - (nose_to_top*1/5));
headsiderp.setX((headsiderp.getX() + 3));
IntensityImageStudent eyes = ImageUtils::subimage(&image, headsidelp, headsiderp);
IntensityImageStudent eyes_dilated = dilation.dilate(&eyes);
StudentHistogram histo{eyes_dilated.getWidth()};
int zero_points[2] = { 0, histo.get_length() * 1 / 7 };
int lowest_found[2] = { eyes_dilated.getHeight(), eyes_dilated.getHeight() };
int left_out = 0, left_out_x = 0,
right_out = 0, right_out_x = 0,
left_in = 0, left_in_x = 0,
right_in = 0, right_in_x = 0;
for (int x = 0; x < histo.get_length(); x++){
temp = 0;
for (int y = 0; y < eyes_dilated.getHeight(); y++){
temp += eyes_dilated.getPixel(x, y) > 127 ? 0 : 1;
}
histo.set_value(x, temp);
if (x < histo.get_length() * 3 / 10 && temp <= lowest_found[0]){
lowest_found[0] = temp;
zero_points[0] = x;
}
if (x > histo.get_length() * 7 / 10 && temp < lowest_found[1]){
lowest_found[1] = temp;
zero_points[1] = x;
}
}
headsidelp.setX(headsidelp.getX() + zero_points[0]);
headsiderp.setX(headsiderp.getX() - (histo.get_length() - zero_points[1]));
headsidelp.setY(top.getY() + (nose_to_top * 2/ 5));
headsiderp.setY(nose_bottom.getY());
IntensityImageStudent eyes2(ImageUtils::subimage(&image, headsidelp, headsiderp));
IntensityImageStudent eyes_copy2(dilation.dilate(&eyes2));
histo.cut_to_size(zero_points[0], zero_points[1]);
for (int x = 0; x < histo.get_length(); x++){
if (x < histo.get_length() * 2 / 9){
left_out_x = histo.get_value(x) > left_out ? x : left_out_x;
left_out = histo.get_value(x) > left_out ? histo.get_value(x) : left_out;
}
else if (x < histo.get_length() * 4 / 9 && x > histo.get_length() * 2 / 9){
left_in_x = histo.get_value(x) > left_in ? x : left_in_x;
left_in = histo.get_value(x) > left_in ? histo.get_value(x) : left_in;
}
else if (x > histo.get_length() * 7 / 9){
right_out_x = histo.get_value(x) > right_out ? x : right_out_x;
right_out = histo.get_value(x) > right_out ? histo.get_value(x) : right_out;
}
else if (x > histo.get_length() * 5 / 9){
right_in_x = histo.get_value(x) > right_in ? x : right_in_x;
right_in = histo.get_value(x) > right_in ? histo.get_value(x) : right_in;
}
}
int forehead_val = 10, forehead_y = 0;
StudentHistogram histo2{eyes_copy2.getHeight()};
for (int y = 0; y < histo2.get_length(); y++){
temp = 0;
for (int x = 0; x < eyes_copy2.getWidth(); x++){
temp += eyes_copy2.getPixel(x, y) > 127 ? 0 : 1;
}
histo2.set_value(y, temp);
}
for (int y = 0; y < histo2.get_length(); y++){
if (histo2.get_value(y) <= forehead_val){
forehead_val = histo2.get_value(y);
forehead_y = y;
}
else if (histo2.get_value(y) > 35 && forehead_val != 10) break;
}
headsidelp.setY(top.getY() + (nose_to_top * 2 / 5) + forehead_y);
forehead_val = 15, forehead_y = histo2.get_length() -1;
for (int y = histo2.get_length() -1; y > 0; --y){
if (histo2.get_value(y) <= forehead_val){
forehead_val = histo2.get_value(y);
forehead_y = y;
}
else if (histo2.get_value(y) > 40 && forehead_val != 15) break;
}
headsiderp.setY(nose_bottom.getY() - (histo2.get_length() - forehead_y + 4));
Point2D<double> precise_ref{headsidelp};
IntensityImageStudent eyes3(ImageUtils::subimage(&image, headsidelp, headsiderp));
IntensityImageStudent eyes_copy3(dilation.dilate(&eyes3));
#ifdef DEBUG
ImageIO::saveIntensityImage(eyes2, ImageIO::getDebugFileName("first eye cut.png"));
ImageIO::saveIntensityImage(eyes_copy3, ImageIO::getDebugFileName("subimage_test3.png"));
#endif // DEBUG
StudentHistogram histo4{ eyes_copy3.getHeight() };
for (int y = 0; y < histo4.get_length(); y++){
temp = 0;
for (int x = 0; x < eyes_copy3.getWidth(); x++){
temp += eyes_copy3.getPixel(x, y) > 127 ? 0 : 1;
}
histo4.set_value(y, temp);
}
#ifdef DEBUG
ImageIO::saveIntensityImage(*histo2.get_debug_image(), ImageIO::getDebugFileName("histo2.png"));
#endif // DEBUG
int step = 0, bottom_eye_y = headsiderp.getY(), top_eye_y = headsidelp.getY() +10;
for (int y = histo4.get_length(); y > 0; --y){
if (step == 0 && histo4.get_value(y) > 30){ bottom_eye_y = y; step++; }
if (step == 1 && histo4.get_value(y) < histo4.get_value(bottom_eye_y)){
top_eye_y = y;
break;
}
}
IntensityImageStudent eyes_precise{eyes3};
for (int x = 0; x < eyes_precise.getWidth(); x++){ eyes_precise.setPixel(x, top_eye_y, 127); eyes_precise.setPixel(x, bottom_eye_y + 2, 127); }
for (int y = 0; y < eyes_precise.getHeight(); y++){
eyes_precise.setPixel(left_in_x, y, 127);
eyes_precise.setPixel(right_in_x, y, 127);
eyes_precise.setPixel(left_out_x, y, 127);
eyes_precise.setPixel(right_out_x, y, 127);
}
bottom_eye_y += 2;
IntensityImageStudent eyes_precise2 = ImageUtils::subimage( &eyes_precise, Point2D<double>{0.0, (double)(top_eye_y)}, Point2D<double>{(double)eyes_precise.getWidth(), (double)bottom_eye_y} );
#ifdef DEBUG
ImageIO::saveIntensityImage(eyes_precise2, ImageIO::getDebugFileName("eyes_precise.png"));
ImageIO::saveIntensityImage(*histo.get_debug_image(), ImageIO::getDebugFileName("histo.png"));
#endif // DEBUG
StudentHistogram histoTopBottom{eyes_precise2.getWidth()};
for (int i = 0; i < histoTopBottom.get_length(); i++){
temp = 0;
for (int j = 0; j < eyes_precise2.getHeight(); j++){
temp += eyes_precise2.getPixel(i, j) > 127? 0: 1;
}
histoTopBottom.set_value(i, temp);
}
#ifdef DEBUG
ImageIO::saveIntensityImage(*histoTopBottom.get_debug_image(), ImageIO::getDebugFileName("histo.png"));
#endif // DEBUG
int outsideLeftX = 0, insideLeftX = 0, insideRightX = 0, outsideRightX = histoTopBottom.get_length()-1;
for (int i = 0; i < histoTopBottom.get_length(); i++){
if (histoTopBottom.get_value(i) > eyes_precise2.getHeight() / 2 && i < histoTopBottom.get_length()*1/4){
outsideLeftX = i;
i = histoTopBottom.get_length() * 1 / 4;
}
else if (histoTopBottom.get_value(i) < eyes_precise2.getHeight() / 3 && i < histoTopBottom.get_length() / 2 && i > histoTopBottom.get_length() * 1 / 4){
insideLeftX = i;
i = histoTopBottom.get_length() / 2;
}
else if (histoTopBottom.get_value(i) > eyes_precise2.getHeight() / 2 && i < histoTopBottom.get_length() * 3 / 4 && i > histoTopBottom.get_length() / 2){
insideRightX = i;
i = histoTopBottom.get_length() * 3 / 4;
}
else if (histoTopBottom.get_value(i) < eyes_precise2.getHeight() / 3 && i > histoTopBottom.get_length() * 3 / 4){
outsideRightX = i;
break;
}
}
#ifdef DEBUG
IntensityImageStudent eyes_precise21 = ImageUtils::subimage(&eyes_precise, Point2D<double>{(double)outsideLeftX, (double)(top_eye_y)}, Point2D<double>{(double)insideLeftX, (double)bottom_eye_y});
ImageIO::saveIntensityImage(eyes_precise21, ImageIO::getDebugFileName("left_eye.png"));
IntensityImageStudent eyes_precise22 = ImageUtils::subimage(&eyes_precise, Point2D<double>{(double)insideRightX, (double)(top_eye_y)}, Point2D<double>{(double)outsideRightX, (double)bottom_eye_y});
ImageIO::saveIntensityImage(eyes_precise22, ImageIO::getDebugFileName("right_eye.png"));
#endif
Feature left = Feature(Feature::FEATURE_EYE_LEFT_RECT);
Feature right = Feature(Feature::FEATURE_EYE_RIGHT_RECT);
left.addPoint(precise_ref + Point2D<double>{(double)outsideLeftX, (double)(top_eye_y)});
left.addPoint(precise_ref + Point2D<double>{(double)insideLeftX, (double)bottom_eye_y});
right.addPoint(precise_ref + Point2D<double>{(double)insideRightX, (double)(top_eye_y)});
right.addPoint(precise_ref + Point2D<double>{(double)outsideRightX, (double)bottom_eye_y});
features.putFeature(right);
features.putFeature(left);
for (int y = 0; y < 3; y++) {
delete[] d_kern[y];
}
delete[] d_kern;
return true;
}
void Entity::Move(Point2D new_path)
{
m_position.SetX(m_position.GetX()+new_path.GetX());
m_position.SetY(m_position.GetY()+new_path.GetY());
}
Eigen::Vector3d
Line2D::getLine(Point2D &p1, Point2D &p2) {
return this->getLine(p1.getPoint()(0), p1.getPoint()(1), p2.getPoint()(0), p2.getPoint()(1));
}
void test12D() {
Point2D pt(1.0, 2.0);
Transform2D trans;
trans.TransformPoint(pt);
CHECK_INVARIANT(abs(pt.x - 1.0) < 1.e-8, "");
CHECK_INVARIANT(abs(pt.y - 2.0) < 1.e-8, "");
Point2D ref1(randNum(), randNum());
Point2D ref2(randNum(), randNum());
std::cout << "ref1: " << ref1 << " ref2: " << ref2 << "\n";
Point2D pt1(randNum(), randNum());
Point2D pt2(randNum(), randNum());
Point2D pt1o = pt1;
Point2D pt2o = pt2;
std::cout << "pt1: " << pt1 << " pt2: " << pt2 << "\n";
Transform2D t2d;
t2d.SetTransform(ref1, ref2, pt1, pt2);
t2d.TransformPoint(pt1);
t2d.TransformPoint(pt2);
// make sure pt1 overlaps ref1
Point2D dif1 = pt1 - ref1;
CHECK_INVARIANT(abs(dif1.x) < 1.e-8, "");
CHECK_INVARIANT(abs(dif1.y) < 1.e-8, "");
// now check that the angle between the two vectors (ref2 - ref1) and
// (pt2 - pt1) is zero
Point2D rvec = ref2 - ref1;
Point2D pvec = pt2 - pt1;
rvec.normalize();
pvec.normalize();
double pdot = rvec.dotProduct(pvec);
CHECK_INVARIANT(abs(pdot - 1.0) < 1.e-8, "");
// compute the reverse transform and make sure we are basically getting the
// identity
Transform2D tdi;
tdi.SetTransform(pt1o, pt2o, pt1, pt2);
tdi.TransformPoint(pt1);
tdi.TransformPoint(pt2);
CHECK_INVARIANT(ptEq(pt1, pt1o), "");
CHECK_INVARIANT(ptEq(pt2, pt2o), "");
// the following product should result in an identity matrix
tdi *= t2d;
tdi.TransformPoint(pt1);
tdi.TransformPoint(pt2);
CHECK_INVARIANT(ptEq(pt1, pt1o), "");
CHECK_INVARIANT(ptEq(pt2, pt2o), "");
Point2D npt1(1.0, 0.0);
Point2D npt2(5.0, 0.0);
Point2D opt1 = npt1;
Point2D opt2(1.0, 4.0);
Transform2D ntd;
ntd.SetTransform(npt1, M_PI / 2);
ntd.TransformPoint(npt1);
ntd.TransformPoint(npt2);
CHECK_INVARIANT(ptEq(npt1, opt1), "");
CHECK_INVARIANT(ptEq(npt2, opt2), "");
}
void AbstractPolygon::checkConvexity()
{
Vertices const & myV(this->vertexes);
auto mysize=this->size();
// We consider segments and triangles as convex
if (mysize <= 3) {
this->isconvex=true;
return;
}
//! Since we are dealing with floating points it is better to have
// a small number so that |a| < smallNumber means for us a==0
double smallNumber(1000*std::numeric_limits<double>::min());
Point2D p;
Point2D v;
Point2D u;
double res(0.0);
double newres(0.0);
//! C++11 sintax. decltype(expr) returns the type of the expression
for ( decltype(mysize) i=0; i < mysize; ++i)
{
p = myV[i];
// ! next point
Point2D tmp = myV[(i+1) % myV.size()];
v = tmp - p;
//! next next point
u = myV[(i+2) % myV.size()];
if (i == 0) // in first loop direction is unknown, so save it in res
res = u.x() * v.y() - u.y() * v.x() + v.x() * p.y() - v.y() * p.x();
else{
newres = u.x() * v.y() - u.y() * v.x() + v.x() * p.y() - v.y() * p.x();
if (std::abs(res)<smallNumber){
// The two edges are aligned, skip test and update res
res=newres;
}
else if ( std::abs(newres)>= smallNumber &&
(newres > 0 && res < 0) || (newres < 0 && res > 0) ){
this->isconvex=false;
return;
}
}
}// end for
this->isconvex=true;
return;
}
bool AbstractTreeDrawing::belongsTo(const Point2D<double>& p1, const Point2D<double>& p2) const
{
return (p1.getX() >= p2.getX() - settings_->pointArea && p1.getX() <= p2.getX() + settings_->pointArea
&& p1.getY() >= p2.getY() - settings_->pointArea && p1.getY() <= p2.getY() + settings_->pointArea);
}
mitk::InteractionEvent::Pointer mitk::EventFactory::CreateEvent(PropertyList::Pointer list)
{
//
std::string eventClass, eventVariant;
list->GetStringProperty(InteractionEventConst::xmlParameterEventClass().c_str(), eventClass);
list->GetStringProperty(InteractionEventConst::xmlParameterEventVariant().c_str(), eventVariant);
// Query all possible attributes, if they are not present, set their default values.
// Position Events & Key Events
std::string strModifiers;
InteractionEvent::ModifierKeys modifiers = InteractionEvent::NoKey;
std::string strEventButton;
InteractionEvent::MouseButtons eventButton = InteractionEvent::NoButton;
std::string strButtonState;
InteractionEvent::MouseButtons buttonState = InteractionEvent::NoButton;
std::string strKey;
std::string key;
std::string strWheelDelta;
int wheelDelta;
std::string strSignalName = "";
Point2D pos;
pos.Fill(0);
std::string strPos;
// Position on screen
if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyPositionOnScreen().c_str(), strPos))
{
// split comma separated string
int commaPos;
commaPos = strPos.find_first_of(',');
pos[0] = static_cast<mitk::ScalarType>(std::atof(strPos.substr(0, commaPos).c_str()));
pos[1] = static_cast<mitk::ScalarType>(std::atof(strPos.substr(commaPos + 1, strPos.length()).c_str()));
}
std::string strWorld;
Point3D worldPos;
worldPos.Fill(0);
// Position in world coordinates
if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyPositionInWorld().c_str(), strWorld))
{
const std::vector<std::string> coords = split(strWorld, ',');
int i = 0;
for (std::vector<std::string>::const_iterator it = coords.cbegin(); it != coords.cend(); ++it, ++i)
{
worldPos[i] = atof((*it).c_str());
}
}
// Parse modifier information
if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyModifier().c_str(), strModifiers))
{
std::vector<std::string> mods = split(strModifiers, ',');
for (std::vector<std::string>::iterator it = mods.begin(); it != mods.end(); ++it)
{
std::transform((*it).cbegin(), (*it).cend(), (*it).begin(), ::toupper);
if (*it == "CTRL")
{
modifiers = modifiers | InteractionEvent::ControlKey;
}
else if (*it == "ALT")
{
modifiers = modifiers | InteractionEvent::AltKey;
}
else if (*it == "SHIFT")
{
modifiers = modifiers | InteractionEvent::ShiftKey;
}
else
{
MITK_WARN << "mitkEventFactory: Invalid event modifier in config file :" << (*it);
}
}
}
// Set EventButton
if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyEventButton().c_str(), strEventButton))
{
std::transform(strEventButton.cbegin(), strEventButton.cend(), strEventButton.begin(), ::toupper);
if (strEventButton == "MIDDLEMOUSEBUTTON")
{
eventButton = InteractionEvent::MiddleMouseButton;
}
else if (strEventButton == "LEFTMOUSEBUTTON")
{
eventButton = InteractionEvent::LeftMouseButton;
}
else if (strEventButton == "RIGHTMOUSEBUTTON")
{
eventButton = InteractionEvent::RightMouseButton;
}
else
{
MITK_WARN << "mitkEventFactory: Invalid event button in config file: " << strEventButton;
}
}
// Parse ButtonStates
if (list->GetStringProperty(InteractionEventConst::xmlEventPropertyButtonState().c_str(), strButtonState))
{
std::vector<std::string> mods = split(strButtonState, ',');
for (std::vector<std::string>::iterator it = mods.begin(); it != mods.end(); ++it)
{
std::transform((*it).cbegin(), (*it).cend(), (*it).begin(), ::toupper);
if (*it == "MIDDLEMOUSEBUTTON")
{
buttonState = buttonState | InteractionEvent::MiddleMouseButton;
}
else if (*it == "LEFTMOUSEBUTTON")
{
buttonState = buttonState | InteractionEvent::LeftMouseButton;
}
else if (*it == "RIGHTMOUSEBUTTON")
{
buttonState = buttonState | InteractionEvent::RightMouseButton;
}
else
{
MITK_WARN << "mitkEventFactory: Invalid event buttonstate in config file:" << (*it);
}
}
}
// Key
if (!list->GetStringProperty(InteractionEventConst::xmlEventPropertyKey().c_str(), strKey))
{
key = "";
}
else
{
key = strKey;
}
// WheelDelta
if (!list->GetStringProperty(InteractionEventConst::xmlEventPropertyScrollDirection().c_str(), strWheelDelta))
{
wheelDelta = 0;
}
else
{
std::transform(strWheelDelta.cbegin(), strWheelDelta.cend(), strWheelDelta.begin(), ::toupper);
if (strWheelDelta == "DOWN")
{
wheelDelta = -1;
}
else
{
wheelDelta = 1;
}
}
// Internal Signals Name
list->GetStringProperty(InteractionEventConst::xmlEventPropertySignalName().c_str(), strSignalName);
// Get BaseRenderer by name
mitk::BaseRenderer *renderer = nullptr;
std::string strRenderer;
// only search for a renderer if there is at least one renderer registered
if (mitk::BaseRenderer::baseRendererMap.size() > 0)
{
if (list->GetStringProperty(mitk::InteractionEventConst::xmlEventPropertyRendererName().c_str(), strRenderer))
{
// look up for renderer registered with the name in xml file
renderer = mitk::BaseRenderer::GetByName(strRenderer);
}
// if not found always use first registered renderer
if (renderer == nullptr)
renderer = (*(mitk::BaseRenderer::baseRendererMap.cbegin())).second;
}
/*
* Here the objects are created
*/
mitk::InteractionEvent::Pointer event;
std::transform(eventClass.cbegin(), eventClass.cend(), eventClass.begin(), ::toupper);
if (eventClass == "MOUSEPRESSEVENT")
{
// buttonstates incorporate the event button (as in Qt)
buttonState = buttonState | eventButton;
event = MousePressEvent::New(renderer, pos, buttonState, modifiers, eventButton);
}
else if (eventClass == "MOUSEDOUBLECLICKEVENT")
{
buttonState = buttonState | eventButton;
event = MouseDoubleClickEvent::New(renderer, pos, buttonState, modifiers, eventButton);
}
else if (eventClass == "MOUSEMOVEEVENT")
{
event = MouseMoveEvent::New(renderer, pos, buttonState, modifiers);
}
else if (eventClass == "MOUSERELEASEEVENT")
{
event = MouseReleaseEvent::New(renderer, pos, buttonState, modifiers, eventButton);
}
else if (eventClass == "INTERACTIONKEYEVENT")
{
event = InteractionKeyEvent::New(renderer, key, modifiers);
}
else if (eventClass == "MOUSEWHEELEVENT")
{
event = MouseWheelEvent::New(renderer, pos, buttonState, modifiers, wheelDelta);
}
else if (eventClass == "INTERACTIONPOSITIONEVENT")
{
event = InteractionPositionEvent::New(renderer, pos);
}
else if (eventClass == "INTERNALEVENT")
{
event = InternalEvent::New(renderer, nullptr, strSignalName);
}
else if (eventClass == "INTERACTIONEVENT")
{
event = InteractionEvent::New(renderer);
}
if (event.IsNull())
{
MITK_WARN << "Event couldn't be constructed. Please check your StateMachine patterns and config files\n for the "
"following event class, which is not valid: "
<< eventClass;
return nullptr;
}
return event;
}
vector<QPoint>
BlurredSegment::getPrintedPoints(){
Point2D d = lastLeftPointAdded;
Point2D f = lastRightPointAdded;
vector<QPoint> vectResult;
double apvh = (double)convexhull->getAPV().height();
double aphl = (double)convexhull->getAPH().large();
vector<Point2D>::iterator iterPoints;
iterPoints = vectorPixel.begin();
int Ymin=0, Ymax=0, Xmax=0, Xmin=0;
bool first = true;
while(iterPoints!=vectorPixel.end()){
Point2D ps = *iterPoints;
if(first){
first= false;
Ymax=ps.getY();
Ymin=ps.getY();
Xmax=ps.getX();
Xmin=ps.getX();
}else{
if(Ymin>ps.getY())
Ymin=ps.getY();
if(Ymax<ps.getY())
Ymax=ps.getY();
if(Xmin>ps.getX())
Xmin=ps.getX();
if(Xmax<ps.getX())
Xmax=ps.getX();
}
iterPoints++;
}
// P5-------- P6//
// P3-------- P4//
if ( apvh < aphl ){
Line lVerti= convexhull->getAPV().getEdge();
Point2DinCV p = convexhull->getAPV().getVertex();
Point2D p1 = lVerti.getBegin();
Point2D p2 = lVerti.getEnd();
double a = tan(getDirection());
double b = -(double)(p1.getX())*a +p1.getY();
double p3 [2] = {Xmax, a*(double)(Xmax)+b};
double p4 [2] = {Xmin, a*(double)(Xmin)+b};
double b2 = -(double)p.getX()*a +(double)p.getY();
double p5[2] = {Xmin, a*(double)(Xmin)+b2};
double p6[2] = {Xmax, a*(double)(Xmax)+b2};
vector<QPoint> droiteSup = PointSet::tracerSegment(QPoint(p3[0],p3[1]),
QPoint(p4[0],p4[1]));
vector<QPoint> droiteInf = PointSet::tracerSegment(QPoint(p5[0],p5[1]),
QPoint(p6[0],p6[1]));
PointSet::fusionVector(vectResult, droiteSup);
PointSet::fusionVector(vectResult, droiteInf);
// cout << "\n" << styleLineXFIG
// << "\n" << (int) p4[0]*RESOLUTION << " " << (int) p4[1]*RESOLUTION << " "
// <<(int) p3[0]*RESOLUTION << " " <<(int) p3[1]*RESOLUTION << " "
// <<(int) p6[0]*RESOLUTION << " " << (int)p6[1]*RESOLUTION << " "
// <<(int) p5[0]*RESOLUTION << " " << (int)p5[1]*RESOLUTION << " "
// <<(int) p4[0]*RESOLUTION << " " << (int) p4[1]*RESOLUTION << endl;
}else{
Line lVerti= convexhull->getAPH().getEdge();
Point2DinCV p = convexhull->getAPH().getVertex();
Point2D p1 = lVerti.getBegin();
Point2D p2 = lVerti.getEnd();
double a = tan(getDirection());
double b = -(double)(p1.getX())*a +p1.getY();
double p3 [2] = {(((double)Ymax)-b)/a,Ymax};
double p4 [2] = {(((double)Ymin)-b)/a,Ymin};
double b2 = -(double)p.getX()*a +(double)p.getY();
double p5[2] = {(((double)Ymin)-b2)/a, Ymin};
double p6[2] = {(((double)Ymax)-b2)/a, Ymax};
if((p2.getX() - p1.getX())==0){
p3[0] = p2.getX();
p3[1] = Ymax;
p4[0] = p2.getX();
p4[1] = Ymin;
p5[0] = p.getX();
p5[1] = Ymin;
p6[0] = p.getX();
p6[1] = Ymax;
}
vector<QPoint> droiteSup = PointSet::tracerSegment(QPoint(p3[0],p3[1]),
QPoint(p4[0],p4[1]));
vector<QPoint> droiteInf = PointSet::tracerSegment(QPoint(p5[0],p5[1]),
QPoint(p6[0],p6[1]));
PointSet::fusionVector(vectResult, droiteSup);
PointSet::fusionVector(vectResult, droiteInf);
// cout << "\n" << styleLineXFIG
// << "\n" << (int) p4[0]*RESOLUTION << " " << (int)p4[1]*RESOLUTION << " "
// << (int)p3[0]*RESOLUTION << " " << (int)p3[1]*RESOLUTION << " "
// << (int)p6[0]*RESOLUTION << " " << (int)p6[1]*RESOLUTION << " "
// << (int)p5[0]*RESOLUTION << " " << (int)p5[1]*RESOLUTION << " "
// << (int) p4[0]*RESOLUTION << " " << (int) p4[1]*RESOLUTION <<endl;
// }
}
return vectResult;
}
// ######################################################################
void CenterSurroundHistogramSegmenter::drawCurrentCSbelief
(Point2D<int> pt, Rectangle grC, Rectangle grS)
{
uint width = itsImage.getWidth();
uint height = itsImage.getHeight();
if(itsWin.is_invalid())
itsWin.reset(new XWinManaged(Dims(2*width, height), 0, 0, "CSHse"));
else itsWin->setDims(Dims(2*width, height));
uint gwidth = width/GRID_SIZE;
uint gheight = height/GRID_SIZE;
// display the window
Image<PixRGB<byte> > disp(2*width, height, ZEROS);
inplacePaste(disp, itsImage, Point2D<int>(0,0));
if(pt.isValid())
{
drawCross(disp, pt, PixRGB<byte>(255,0,0), 10, 1);
}
if(grC.isValid())
{
drawRect(disp, grC*GRID_SIZE, PixRGB<byte>(255,0,0), 1);
drawRect(disp, grS*GRID_SIZE, PixRGB<byte>(0,255,0), 1);
}
float mVal = 32;
float bVal = 255 - mVal;
Image<byte> dImaR, dImaG, dImaB;
getComponents(itsImage, dImaR, dImaG, dImaB);
inplaceNormalize(dImaR, byte(0), byte(mVal));
inplaceNormalize(dImaG, byte(0), byte(mVal));
inplaceNormalize(dImaB, byte(0), byte(mVal));
Image<PixRGB<byte> > dIma = makeRGB(dImaR,dImaG,dImaB);
// Image<float> dImaCf = itsGridCenterBelief;
// inplaceNormalize(dImaCf, 0.0F, bVal);
// Image<byte> dImaCb(dImaCf);
// Image<PixRGB<byte> > dImaC = makeRGB(dImaCb,dImaCb,dImaCb);
// Image<float> dImaSf = itsGridSurroundBelief;
// inplaceNormalize(dImaSf, 0.0F, bVal);
// Image<byte> dImaSb(dImaSf);
// Image<PixRGB<byte> > dImaS = makeRGB(dImaSb,dImaSb,dImaSb);
// Image<PixRGB<byte> > tdImaC(dIma+zoomXY(dImaC,GRID_SIZE));
// Image<PixRGB<byte> > tdImaS(dIma+zoomXY(dImaS,GRID_SIZE));
// inplacePaste (disp, tdImaC, Point2D<int>(width,0));
// inplacePaste (disp, tdImaS, Point2D<int>(2*width,0));
Image<float> dImaCSf =
clampedDiff((itsGridCenterBelief - itsGridSurroundBelief),
Image<float>(gwidth,gheight,ZEROS));
inplaceNormalize(dImaCSf, 0.0F, bVal);
Image<byte> dImaCSb(dImaCSf);
Image<PixRGB<byte> > dImaCS = makeRGB(dImaCSb,dImaCSb,dImaCSb);
Image<PixRGB<byte> > tdImaCS(dIma+zoomXY(dImaCS,GRID_SIZE));
inplacePaste (disp, tdImaCS, Point2D<int>(width,0));
Point2D<int> noff (width,0);
drawCross(disp, pt+noff, PixRGB<byte>(255,0,0), 10, 1);
if(itsCSrectangle.isValid())
{
drawRect(disp, itsCSrectangle*GRID_SIZE, PixRGB<byte>(255,0,0), 1);
drawRect(disp, (itsCSrectangle*GRID_SIZE)+noff, PixRGB<byte>(255,0,0), 1);
}
itsWin->drawImage(disp,0,0);
Raster::waitForKey();
}
bool operator()(const Point2D& p, const Point2D& q)
{
return (p.getX() < q.getX());
}
bool JumpDistanceSegmentation::isJumpBetween(const Point2D* p1, const Point2D* p2)
{
const Point2D diff = *p1 - *p2;
return diff.norm() > m_jumpDistance;
}
char* StagePreview::savePreviewImage(sf::RenderWindow *window,
BerryBotsEngine *engine, unsigned int &targetWidth,
unsigned int &targetHeight) {
Stage *stage = engine->getStage();
double backingScale = getBackingScaleFactor();
unsigned int viewWidth = stage->getWidth() + (2 * STAGE_MARGIN);
unsigned int viewHeight = stage->getHeight() + (2 * STAGE_MARGIN);
unsigned int screenWidth = backingScale * MAX_PREVIEW_WIDTH;
unsigned int screenHeight = backingScale * MAX_PREVIEW_HEIGHT;
double windowScale =
std::min(backingScale, std::min(((double) screenWidth) / viewWidth,
((double) screenHeight) / viewHeight));
targetWidth = round(windowScale * viewWidth);
targetHeight = round(windowScale * viewHeight);
#ifdef __WXGTK__
// Since setSize() doesn't work reliably, we create it inline on Linux.
window = new sf::RenderWindow(
sf::VideoMode(targetWidth, targetHeight), "Preview",
sf::Style::None,
sf::ContextSettings(0, 0, (isAaDisabled() ? 0 : 4), 2, 0));
window->setVisible(false);
#else
window->setSize(sf::Vector2u(targetWidth, targetHeight));
#endif
Team **teams = new Team*[1];
teams[0] = new Team;
strcpy(teams[0]->name, "PreviewTeam");
teams[0]->numRectangles = 0;
teams[0]->numLines = 0;
teams[0]->numCircles = 0;
teams[0]->numTexts = 0;
Ship **ships = new Ship*[1];
Ship *ship = new Ship;
ShipProperties *properties = new ShipProperties;
properties->shipR = properties->shipG = properties->shipB = 255;
properties->laserR = properties->laserB = 0;
properties->laserG = 255;
properties->thrusterR = 255;
properties->thrusterG = properties->thrusterB = 0;
strcpy(properties->name, "PreviewShip");
ship->properties = properties;
ship->thrusterAngle = ship->thrusterForce = 0;
Point2D *start = stage->getStart();
ship->x = start->getX();
ship->y = start->getY();
ship->alive = true;
ship->showName = ship->energyEnabled = false;
ships[0] = ship;
teams[0]->numTexts = 0;
stage->setTeamsAndShips(teams, 1, ships, 1);
previewGfxManager_->initBbGfx(window, backingScale, viewHeight, stage, teams,
1, ships, 1);
previewGfxManager_->initViews(window, viewWidth, viewHeight);
GfxEventHandler *gfxHandler = new GfxEventHandler();
window->clear();
previewGfxManager_->drawGame(window, stage, ships, 1, 0, gfxHandler, false,
false, 0);
std::stringstream filenameStream;
filenameStream << (rand() % 10000000) << ".png";
char *filename = fileManager_->getFilePath(getTmpDir().c_str(),
filenameStream.str().c_str());
char *absFilename = fileManager_->getAbsFilePath(filename);
delete filename;
sf::Image previewImage = window->capture();
fileManager_->createDirectoryIfNecessary(getTmpDir().c_str());
previewImage.saveToFile(absFilename);
#ifdef __WXGTK__
delete window;
#endif
previewGfxManager_->destroyBbGfx();
delete gfxHandler;
delete properties;
delete teams[0];
delete teams;
return absFilename;
}
int Hash2D::getHashKey(const Point2D& a)
{
int x = floor(a.getPx()/cellwidth);
int y = floor(a.getPy()/cellwidth);
return y*cols + x;
}
mitk::Point2D mitk::PlanarCross::InternalApplyControlPointConstraints( unsigned int index, const Point2D& point )
{
// Apply constraints depending on current interaction state
switch ( index )
{
case 2:
{
// Check if 3rd control point is outside of the range (2D area) defined by the first
// line (via the first two control points); if it is outside, clip it to the bounds
const Point2D p1 = this->GetControlPoint( 0 );
const Point2D p2 = this->GetControlPoint( 1 );
Vector2D n1 = p2 - p1;
n1.Normalize();
const Vector2D v1 = point - p1;
const double dotProduct = n1 * v1;
const Point2D crossPoint = p1 + n1 * dotProduct;;
const Vector2D crossVector = point - crossPoint;
if ( dotProduct < 0.0 )
{
// Out-of-bounds on the left: clip point to left boundary
return (p1 + crossVector);
}
else if ( dotProduct > p2.EuclideanDistanceTo( p1 ) )
{
// Out-of-bounds on the right: clip point to right boundary
return (p2 + crossVector);
}
else
{
// Pass back original point
return point;
}
}
case 3:
{
// Constrain 4th control point so that with the 3rd control point it forms
// a line orthogonal to the first line (constraint 1); the 4th control point
// must lie on the opposite side of the line defined by the first two control
// points than the 3rd control point (constraint 2)
const Point2D p1 = this->GetControlPoint( 0 );
const Point2D p2 = this->GetControlPoint( 1 );
const Point2D p3 = this->GetControlPoint( 2 );
// Calculate distance of original point from orthogonal line the corrected
// point should lie on to project the point onto this line
Vector2D n1 = p2 - p1;
n1.Normalize();
const Vector2D v1 = point - p3;
const double dotProduct1 = n1 * v1;
const Point2D pointOnLine = point - n1 * dotProduct1;
// Project new point onto line [p1, p2]
const Vector2D v2 = pointOnLine - p1;
double dotProduct2 = n1 * v2;
const Point2D crossingPoint = p1 + n1 * dotProduct2;
// Determine whether the projected point on the line, or the crossing point should be
// used (according to the second constraint in the comment above)
if ( (pointOnLine.SquaredEuclideanDistanceTo( p3 ) > crossingPoint.SquaredEuclideanDistanceTo( p3 ))
&& (pointOnLine.SquaredEuclideanDistanceTo( p3 ) > pointOnLine.SquaredEuclideanDistanceTo( crossingPoint )) )
{
return pointOnLine;
}
else
{
return crossingPoint;
}
}
default:
return point;
}
}
void draw(){
cout<<"center = ";
center.display();
cout<<endl<<"radius = "<<radius<<endl;
};
int main(int argc, char* argv[])
{
CS325Graphics window(argc, argv);
float delta = 0.1;
Point2D p1(CS325Graphics::X_MIN, CS325Graphics::Y_MAX / 4.5);
Point2D p2(CS325Graphics::X_MAX, CS325Graphics::Y_MAX / 4.5);
Point2D p3(CS325Graphics::X_MIN, CS325Graphics::Y_MIN);
Point2D p4(CS325Graphics::X_MAX, CS325Graphics::Y_MAX);
//Points 41, 42, 45, 46 control the sandbox. DON"T MESS WITH THEM!
Point3D p30(0.5, 0.5,-3.5);
Point3D p31(0.5, -0.5,-3.5);
Point3D p32(-0.5,-0.5,-3.5);
Point3D p33(-0.5, 0.5,-3.5);
Point3D p34(0.5, 0.5,-1.5);
Point3D p35(0.5, -0.5,-1.5);
Point3D p36(-0.5,-0.5,-1.5);
Point3D p37(-0.5, 0.5,-1.5);
Point3D p40( -70.8, 28.8, -50.8);
Point3D p41( 50.8,-2.8, 50.8);
Point3D p42(-50.8,-2.8, 50.8);
Point3D p43(-58.8, 25.8, 50.8);
Point3D p44( 50.8, 50.8, -50.8);
Point3D p45( 50.8,-2.8, -50.8);
Point3D p46(-50.8,-2.8, -50.8);
Point3D p47(-84.8,-2.8, -50.8);
Point3D p49(-8.5,22.0, 50.8);
Point3D p48(70,20,50.8);
Point3D p50(3.5, 0.5,-3.5);
Point3D p51(3.5, -0.5,-3.5);
Point3D p52(2.5,-0.5,-3.5);
Point3D p53(2.5, 0.5,-3.5);
Point3D p54(3.5, 0.5,-1.5);
Point3D p55(3.5, -0.5,-1.5);
Point3D p56(2.5,-0.5,-1.5);
Point3D p57(2.5, 0.5,-1.5);
Point3D p60(3.5, 0.5, 13.5);
Point3D p61(3.5, -0.5, 13.5);
Point3D p62(2.5,-0.5, 13.5);
Point3D p63(2.5, 0.5, 13.5);
Point3D p64(3.5, 0.5, 16.5);
Point3D p65(3.5, -0.5, 16.5);
Point3D p66(2.5,-0.5, 16.5);
Point3D p67(2.5, 0.5, 16.5);
Point2D viewPos;
Vector2D viewDir;
Vector3D deltaV;
viewDir.setAngle(0);
// move view position
for(int i = 0; i < MOVE_TEST; i){
/*window.DrawLineOnScreen(p1, p2);*/
//window.DrawLineOnScreen(p4, p3);
window.DrawLineInSpace(p30, p31);
window.DrawLineInSpace(p31, p32);
window.DrawLineInSpace(p32, p33);
window.DrawLineInSpace(p33, p30);
window.DrawLineInSpace(p34, p35);
window.DrawLineInSpace(p35, p36);
window.DrawLineInSpace(p36, p37);
window.DrawLineInSpace(p37, p34);
window.DrawLineInSpace(p30, p34);
window.DrawLineInSpace(p31, p35);
window.DrawLineInSpace(p32, p36);
window.DrawLineInSpace(p33, p37);
window.DrawLineInSpace(p50, p51);
window.DrawLineInSpace(p51, p52);
window.DrawLineInSpace(p52, p53);
window.DrawLineInSpace(p53, p50);
window.DrawLineInSpace(p54, p55);
window.DrawLineInSpace(p55, p56);
window.DrawLineInSpace(p56, p57);
window.DrawLineInSpace(p57, p54);
window.DrawLineInSpace(p50, p54);
window.DrawLineInSpace(p51, p55);
window.DrawLineInSpace(p52, p56);
window.DrawLineInSpace(p53, p57);
window.DrawLineInSpace(p60, p61);
window.DrawLineInSpace(p61, p62);
window.DrawLineInSpace(p62, p63);
window.DrawLineInSpace(p63, p60);
window.DrawLineInSpace(p64, p65);
window.DrawLineInSpace(p65, p66);
window.DrawLineInSpace(p66, p67);
window.DrawLineInSpace(p67, p64);
window.DrawLineInSpace(p60, p64);
window.DrawLineInSpace(p61, p65);
window.DrawLineInSpace(p62, p66);
window.DrawLineInSpace(p63, p67);
//window.DrawLineInSpace(p40, p41);
window.DrawLineInSpace(p41, p42);
window.DrawLineInSpace(p42, p43);
//window.DrawLineInSpace(p43, p40);
//window.DrawLineInSpace(p44, p45);
window.DrawLineInSpace(p45, p46);
//window.DrawLineInSpace(p46, p47);
//window.DrawLineInSpace(p47, p44);
window.DrawLineInSpace(p40, p45);
window.DrawLineInSpace(p41, p45);
window.DrawLineInSpace(p42, p46);
window.DrawLineInSpace(p43, p47);
window.DrawLineInSpace(p40, p47);
window.DrawLineInSpace(p41, p49);
window.DrawLineInSpace(p42, p49);
window.DrawLineInSpace(p41, p48);
window.DrawLineInSpace(p45, p48);
if(GetAsyncKeyState(VK_DOWN)) // the DOWN arrow was pressed, let's do something
{
delta = -.1;
viewPos.setY(viewPos.getY() + cos(-viewDir.getAngle())*delta);
viewPos.setX(viewPos.getX() + sin(-viewDir.getAngle())*delta);
window.SetViewPosition(viewPos);
cout << "view pos: " << viewPos.toString() << endl;
window.DisplayNow();
Sleep(50);
}
if(GetAsyncKeyState(VK_UP)) // the UP arrow was pressed, let's do something
{
delta = .1;
viewPos.setY(viewPos.getY() + cos(-viewDir.getAngle())*delta);
viewPos.setX(viewPos.getX() + sin(-viewDir.getAngle())*delta);
window.SetViewPosition(viewPos);
cout << "view pos: " << viewPos.toString() << endl;
window.DisplayNow();
Sleep(50);
}
if(GetAsyncKeyState(VK_RIGHT)) // the RIGHT arrow was pressed, let's do something
{
delta = .1;
viewDir.setAngle(viewDir.getAngle()+delta);
window.SetViewDirection(viewDir);
cout << "view dir: " << viewDir.getAngle() << endl;
window.DisplayNow();
Sleep(50);
}
if(GetAsyncKeyState(VK_LEFT)) // the LEFT arrow was pressed, let's do something
{
delta = -.1;
viewDir.setAngle(viewDir.getAngle()+delta);
window.SetViewDirection(viewDir);
cout << "view dir: " << viewDir.getAngle() << endl;
window.DisplayNow();
Sleep(50);
}
if(GetAsyncKeyState(VK_ESCAPE))
{
return 1;
}
}
}
void Font::PrintText(const char * text, const Point2D& pos, const Rect& bounds, uint8 format) const
{
Point2D offset;
glPushMatrix();
glLoadIdentity();
glColor(Black);
glTranslated(pos.GetX(), pos.GetY(), 0);
uint8 justify = format & 0x03;
Float lineOffset = (int32)(CalculateLineLength(text, bounds.GetWidth(), 0)/2.0 * justify);
offset.SetValues(offset.GetX() + lineOffset, offset.GetY());
glTranslated(lineOffset, 0.0, 0);
uint32 textPos = 0;
while (textPos < strlen(text))
{
bool wordBegin = true;
uint32 wordLength = GetWordLength(text, textPos);
uint32 wordSpace = GetWordSpace(text, textPos);
for (uint32 i = textPos; i < textPos + wordLength; i++)
{
if (text[i] == '&')
{
ParseSpecial(text, i, true);
continue;
}
else if (((text[i] == '\n') || ((text[i] == '\\') && (text[i+1] == 'n')) || (offset.GetX() > bounds.GetWidth())) || ((wordSpace + offset.GetX() >= bounds.GetWidth()) && (wordSpace < bounds.GetWidth()) && (wordBegin == true)))
{
glTranslated(-offset.GetX(), baseSize, 0);
offset.SetValues(0, offset.GetY() + baseSize);
if (offset.GetY() > bounds.GetHeight())
{
glPopMatrix();
return;
}
lineOffset = (int32)(CalculateLineLength(text, bounds.GetWidth(), i + 1)/2.0 * justify);
offset.SetValues(offset.GetX() + lineOffset, offset.GetY());
glTranslated(lineOffset, 0.0, 0);
if (text[i] == '\n')
{
continue;
}
else if ((text[i] == '\\') && (text[i+1] == 'n'))
{
i++;
continue;
}
}
glCallList(text[i] + displayLists);
offset.SetValues(offset.GetX() + width[text[i]], offset.GetY());
wordBegin = false;
}
offset.SetValues(offset.GetX() + baseSize, offset.GetY());
glTranslated(baseSize, 0, 0);
textPos += wordLength + 1;
}
glPopMatrix();
}
double Point2D::distanceSq(Point2D p) {
return square(p.getX() - x_) + square(p.getY() - y_);
}
// ######################################################################
int main(const int argc, const char **argv)
{
MYLOGVERB = LOG_INFO; // suppress debug messages
volatile int signum = 0;
catchsignals(&signum);
ModelManager manager("Test Motion Energy");
nub::ref<InputFrameSeries> ifs(new InputFrameSeries(manager));
manager.addSubComponent(ifs);
nub::ref<OutputFrameSeries> ofs(new OutputFrameSeries(manager));
manager.addSubComponent(ofs);
nub::ref<FoeDetector> fd(new FoeDetector(manager));
manager.addSubComponent(fd);
if (manager.parseCommandLine((const int)argc, (const char**)argv,
"<stimuli> <options>", 0, 9) == false)
return(1);
fd->reset(NUM_PYR_LEVEL, NUM_DIRS, NUM_SPEEDS);
std::string stimuli("Image");
if(manager.numExtraArgs() > 0)
stimuli = manager.getExtraArgAs<std::string>(0);
LINFO("Stimuli: %s", stimuli.c_str());
manager.start();
Timer timer(1000000);
timer.reset(); // reset the timer
int frame = 0;
PauseWaiter p;
uint step; step = 0;
// to get to the good part
//for(uint i = 0; i < 50; i++) //was 25
// ifs->updateNext();
// get ground truth file
std::string gtFilename
("/lab/tmpib/u/siagian/neuroscience/Data/FOE/driving_nat_Browning.txt");
std::vector<Point2D<int> > gt = getGT(gtFilename);
int ldpos = gtFilename.find_last_of('.');
std::string prefix = gtFilename.substr(0, ldpos);
// for finding ground truth
rutz::shared_ptr<XWinManaged> win;
float totalErr = 0.0;
std::vector<std::string> args;
for(uint i = 0; i < manager.numExtraArgs(); i++)
args.push_back(manager.getExtraArgAs<std::string>(i));
Image<byte> prevLum;
Image<PixRGB<byte> > prevImage;
Image<PixRGB<byte> > prevImage2;
while (1)
{
if (signum != 0)
{
LINFO("quitting because %s was caught", signame(signum));
break;
}
if (ofs->becameVoid())
{
LINFO("quitting because output stream was closed or became void");
break;
}
if (p.checkPause())
continue;
const FrameState is = ifs->updateNext();
if (is == FRAME_COMPLETE) break; // done receiving frames
Image< PixRGB<byte> > input = ifs->readRGB();
if(frame == 0)
{
uint width = input.getWidth();
uint height = input.getHeight();
win.reset(new XWinManaged(Dims(width, height), 0, 0, "GT"));
}
// empty image signifies end-of-stream
if (!input.initialized()) break;
Image<byte> lum = luminance(input);
Point2D<float> pshift(0.0,0.0);
if(step != 0)
{
// calculate planar shift using SIFT
lum = calculateShift(lum,prevLum, ofs);
}
if( manager.numExtraArgs() > 0)
lum = getImage(stimuli, args, fd, step);
// for saving videos
prevImage2 = prevImage;
prevImage = input;
if (!lum.initialized()) break; step++;
// compute the focus of expansion (FOE)
Point2D<int> foe = fd->getFoe(lum, FOE_METHOD_TEMPLATE, false);
//Point2D<int> foe = fd->getFoe(lum, FOE_METHOD_AVERAGE);
LINFO("[%d]Foe: %d %d", frame, foe.i, foe.j);
// illustration of the size of the receptive field
if(!stimuli.compare("ShowRF"))
{
uint rfI = 44;
uint rfJ = 152;
lum.setVal(rfI, rfJ, 300.0F);
drawRect(lum, Rectangle::tlbrI(144,36,159,51), byte(255));
drawRect(lum, Rectangle::tlbrI(148,40,155,47), byte(255));
drawRect(lum, Rectangle::tlbrI(rfJ-8, rfI-8, rfJ+8, rfI+8), byte(255));
drawRect(lum, Rectangle::tlbrI(rfJ-16,rfI-16,rfJ+16,rfI+16), byte(255));
}
ofs->writeGrayLayout(fd->getMTfeaturesDisplay(lum), "MT Features",
FrameInfo("motion energy output images", SRC_POS));
// write the file
if(frame >= 4)
{
float err = foe.distance(gt[frame-2]);
totalErr += err;
LINFO("Foe: %d %d: GT: %d %d --> %f --> avg: %f",
foe.i, foe.j, gt[frame-2].i, gt[frame-2].j,
err, totalErr/(frame-3));
Image<PixRGB<byte> > simg = prevImage2;
drawCross(simg, foe , PixRGB<byte>(0,255,0), 10, 2);
drawCross(simg, gt[frame-2], PixRGB<byte>(255,0,0), 10, 2);
win->drawImage(simg,0,0);
//Raster::WriteRGB(simg, sformat("%s_STnPS_%06d.ppm", prefix.c_str(), frame-2));
}
//ofs->writeGrayLayout
// (lum, "test-FOE Main", FrameInfo("foe output", SRC_POS));
const FrameState os = ofs->updateNext();
//LINFO("frame[%d]: %8.3f %8.3f", frame, pshift.i, pshift.j);
Raster::waitForKey();
if (os == FRAME_FINAL)
break;
prevLum = lum;
frame++;
}
LINFO("%d frames in %gs (%.2ffps)\n",
frame, timer.getSecs(), frame / timer.getSecs());
// stop all our ModelComponents
manager.stop();
// all done!
return 0;
}
IntensityImageStudent ImageUtils::subimage(const IntensityImage * image, const Point2D<double> left_top, const Point2D<double> right_down)
{
int left_x = 0;
int right_x = image->getWidth();
int left_y = 0;
int right_y = image->getHeight();
if (left_top.getX() > right_down.getX()){
left_x = right_down.getX();
right_x = left_top.getX();
}
else if (left_top.getX() < right_down.getX()){
left_x = left_top.getX();
right_x = right_down.getX();
}
if (left_top.getY() > right_down.getY()){
left_y = right_down.getY();
right_y = left_top.getY();
}
else if (left_top.getY() < right_down.getY()){
left_y = left_top.getY();
right_y = right_down.getY();
}
IntensityImageStudent result(right_x - left_x, right_y - left_y);
for (int y = left_y; y < right_y; y++) {
for (int x = left_x; x < right_x; x++) {
result.setPixel(x - left_x, y - left_y, image->getPixel(x, y));
}
}
return result;
}
bool
Line2D::hasPoint(Point2D &p) {
return this->v(0) * p.getPoint()(0) + this->v(1) * p.getPoint()(1) + this->v(2) == 0;
}
Map::Points Map::nearPoints(const Point2D& point){
return{ point.subtract({ 1, 0 }), point.add({ 1, 0 }), point.subtract({ 0, 1 }), point.add({ 0, 1 }) };
}
Line2D
Line2D::getNormalLine(Point2D &p) {
return this->getNormalLine(p.getPoint()(0), p.getPoint()(1));
}
Point2D
UIRectangle::vpToLocal(Point2D pt) { return tl + pt.div(_scale); }
void mitk::PlanarDoubleEllipse::GeneratePolyLine()
{
this->ClearPolyLines();
Point2D centerPoint = this->GetControlPoint(0);
Point2D outerMajorPoint = this->GetControlPoint(1);
Vector2D direction = outerMajorPoint - centerPoint;
direction.Normalize();
const ScalarType deltaAngle = vnl_math::pi / (m_NumberOfSegments / 2);
int start = 0;
int end = m_NumberOfSegments;
if (direction[1] < 0.0)
{
direction[0] = -direction[0];
end = m_NumberOfSegments / 2;
start = -end;
}
vnl_matrix_fixed<mitk::ScalarType, 2, 2> rotation;
rotation[1][0] = std::sin(std::acos(direction[0]));
rotation[0][0] = direction[0];
rotation[1][1] = direction[0];
rotation[0][1] = -rotation[1][0];
ScalarType outerMajorRadius = centerPoint.EuclideanDistanceTo(outerMajorPoint);
ScalarType outerMinorRadius = centerPoint.EuclideanDistanceTo(this->GetControlPoint(2));
ScalarType innerMajorRadius = centerPoint.EuclideanDistanceTo(this->GetControlPoint(3));
ScalarType innerMinorRadius = innerMajorRadius - (outerMajorRadius - outerMinorRadius);
ScalarType angle;
ScalarType cosAngle;
ScalarType sinAngle;
vnl_vector_fixed<mitk::ScalarType, 2> vector;
Point2D point;
for (int i = start; i < end; ++i)
{
angle = i * deltaAngle;
cosAngle = std::cos(angle);
sinAngle = std::sin(angle);
vector[0] = outerMajorRadius * cosAngle;
vector[1] = outerMinorRadius * sinAngle;
vector = rotation * vector;
point[0] = centerPoint[0] + vector[0];
point[1] = centerPoint[1] + vector[1];
this->AppendPointToPolyLine(0, point);
vector[0] = innerMajorRadius * cosAngle;
vector[1] = innerMinorRadius * sinAngle;
vector = rotation * vector;
point[0] = centerPoint[0] + vector[0];
point[1] = centerPoint[1] + vector[1];
this->AppendPointToPolyLine(1, point);
}
}
bool Rectangle::is_point_within(const Point2D& p) const {
return
(p.x() <= m_upper_right.x() && p.y() <= m_upper_right.y()) ||
(p.x() >= m_lower_left.x() && p.y() >= m_lower_left.y());
}
bool operator()(Point2D& a, Point2D& b){
return (a.getx()<b.getx());
}
bool StudentLocalization::stepFindChinContours(const IntensityImage &image, FeatureMap &features) const {
// Maak een basetimer object om de tijd bij te houden dat de implementatie nodig heeft.
BaseTimer basetimer;
// Start de basetimer.
basetimer.start();
// test getal
int startStep = 15;
bool first = true;
// Sla het middenpunt van de mond op.
Point2D<double> MouthCenterPoint = features.getFeature(Feature::FEATURE_MOUTH_CENTER).getPoints()[0];
// Sla het kin punt op.
Point2D<double> ChinPoint = features.getFeature(Feature::FEATURE_CHIN).getPoints()[0];
int range = MouthCenterPoint.getY() - ChinPoint.getY();
// Object om kincountoer punten in op te slaan.
Feature output = Feature(Feature::FEATURE_CHIN_CONTOUR);
int degrees;
int steps = 15;
int lastdif;
double correction = -1;
int lastSteps = 0;
int vorigeX = 0;
// Bereken 20 punten van de kin.
for (int i = 0; i < 19; i++)
{
bool ireg = false;
if (i>9)
{
correction = 1;
}
else if (i < 9)
{
correction =0;
}
// Sla middelpunt mond x op.
int checkX = MouthCenterPoint.getX();
// Sla middelpunt mond y op.
int checkY = MouthCenterPoint.getY();
double gradenInRad = (-90+(i * 10)) *(PI/180);
steps = startStep;
Point2D<double> gevondenPunt;
// Middelste punt van de kin is als het goed is bekend. Dit is punt nummer 9 dus zal worden overgeslagen.
if (i != 9)
{
while (true)
{
if (!first&&steps > startStep + 10)
{
lastdif / i;
ireg = true;
gevondenPunt.set(MouthCenterPoint.getX() + ((lastSteps + correction)* std::sin(gradenInRad)), MouthCenterPoint.getY() + ((lastSteps + correction) * std::cos(gradenInRad)));
steps = lastSteps + correction;
break;
}
checkX = MouthCenterPoint.getX()+ (steps * std::sin(gradenInRad));
checkY = MouthCenterPoint.getY()+(steps * std::cos(gradenInRad));
Intensity pixel = image.getPixel(std::round(checkX), std::round(checkY));
if (int(pixel) == 0)
{
if (checkX - vorigeX <2)
{
lastdif / i;
ireg = true;
gevondenPunt.set(MouthCenterPoint.getX() + ((lastSteps + correction)* std::sin(gradenInRad)), MouthCenterPoint.getY() + ((lastSteps + correction) * std::cos(gradenInRad)));
steps = lastSteps + correction;
break;
}
ireg=false;
gevondenPunt.set(checkX, checkY); break;
}
steps++;
}
vorigeX = checkX;
std::cout << gevondenPunt <<"\n";
startStep = steps - 5;
output.addPoint(Point2D<double>(gevondenPunt.x,gevondenPunt.y));
first=false;
if (ireg)
{
startStep = steps-5;
lastSteps = steps;
}
else
{
lastdif = lastSteps - steps;
lastSteps = steps;
}
}
else
{
output.addPoint(ChinPoint);
}
}
features.putFeature(output);
basetimer.stop();
std::ofstream myfile;
myfile.open("tijd.txt", std::ofstream::ate);
myfile << "Chincontours convert tijd in s: " << basetimer.elapsedSeconds() << " tijd ms:" << basetimer.elapsedMilliSeconds() << " tijd us" << basetimer.elapsedMicroSeconds();
myfile.close();
return true;
}
