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; }