Tekkotsu Homepage

Demos

Overview

Downloads

Dev. Resources

Reference

Credits

LineData.cc Go to the documentation of this file. //-*-c++-*- #include <iostream> #include <math.h> #include <vector> #include <list> #include "Macrodefs.h" #include "SketchSpace.h" #include "Sketch.h" #include "Region.h" #include "visops.h" #include "ShapeSpace.h" #include "ShapeRoot.h" #include "PointData.h" #include "LineData.h" #include "ShapeLine.h" using namespace std; namespace DualCoding { DATASTUFF_CC(LineData); const Point LineData::origin_pt = Point(0,0); LineData::LineData(ShapeSpace& _space, const Point &p1, orientation_t orient) : BaseData(_space,getStaticType()), end1_pt(p1), end2_pt(), rho_norm(0), theta_norm(0), orientation(0), length(0) { int const width = space->getDualSpace().getWidth(); int const height = space->getDualSpace().getHeight(); // Use a large offset from p1 to p2 because SketchGUI must calculate // the line slope from p1/p2 coords transmitted as strings; we don't // transmit the orientation. But don't use an offset so large that the line // goes off-screen. float p2x=0, p2y=0; if ( fabs(orient-M_PI/2) < 0.001 ) { p2x = p1.coordX(); p2y = p1.coordY() > height/2 ? 0 : height-1; } else { float slope = tan(orient); float intcpt = p1.coordY() - p1.coordX()*slope; p2x = p1.coordX() >= width/2 ? 0.0 : width-1; p2y = p2x * slope + intcpt; if ( p2y > height-1 ) { p2x = (height - intcpt) / slope; p2y = height; } else if ( p2y < 0 ) { p2x = -intcpt / slope; p2y = 0; } } end2_pt = Point(p2x,p2y); end1_pt.setValid(false); end1_pt.setActive(false); end2_pt.setValid(false); end2_pt.setActive(false); update_derived_properties(); } Point LineData::getCentroid() const { return (end1Pt()+end2Pt())*0.5; } void LineData::setInfinite(bool value) { end1_pt.setActive(!value); end2_pt.setActive(!value); } #define NORMPOINT_MATCH_DISTSQ 3500 #define LINE_MATCH_OVERLAP -10 #define LINE_ORIENTATION_MATCH M_PI/6 bool LineData::isMatchFor(const ShapeRoot& other) const { if (!(isSameTypeAs(other) && isSameColorAs(other))) return false; else { const Shape<LineData>& other_ln = ShapeRootTypeConst(other,LineData); return isMatchFor(other_ln.getData()); } } bool LineData::isMatchFor(const LineData& other_line) const { float const px = rho_norm*cos(theta_norm), py = rho_norm*sin(theta_norm); float const qx = other_line.rho_norm*cos(other_line.theta_norm), qy = other_line.rho_norm*sin(other_line.theta_norm); AngPi theta_diff = float(theta_norm) - float(other_line.theta_norm); if ( theta_diff > M_PI/2 ) theta_diff = M_PI - theta_diff; float normpointdistsq = (px-qx)*(px-qx) + (py-qy)*(py-qy); // cout << "px=" << px << " py=" << py << " qx=" << qx << " qy=" << qy << " normpointdistsq=" << normpointdistsq // << " theta_diff=" << theta_diff // << " perpdist=" << perpendicularDistanceFrom(other_line.getCentroid()) // << " isoverlapped=" << isOverlappedWith(other_line,LINE_MATCH_OVERLAP) << endl; return normpointdistsq < NORMPOINT_MATCH_DISTSQ // *** DST hack && theta_diff < LINE_ORIENTATION_MATCH && perpendicularDistanceFrom(other_line.getCentroid()) < 100 && isOverlappedWith(other_line,LINE_MATCH_OVERLAP); } bool LineData::isOverlappedWith(const LineData& otherline, int amount) const { if ( firstPtCoord() <= otherline.firstPtCoord() ) return secondPtCoord()-amount >= otherline.firstPtCoord(); else return firstPtCoord()+amount <= otherline.secondPtCoord(); } void LineData::mergeWith(const ShapeRoot& other) { const Shape<LineData>& other_line = ShapeRootTypeConst(other,LineData); if (other_line->confidence <= 0) return; const int other_conf = other_line->confidence; confidence += other_conf; end1_pt = (end1_pt*confidence + other_line->end1Pt()*other_conf) / (confidence+other_conf); end2_pt = (end2_pt*confidence + other_line->end2Pt()*other_conf) / (confidence+other_conf); update_derived_properties(); } bool LineData::isValidUpdate(coordinate_t c1_cur, coordinate_t c2_cur, coordinate_t c1_new, coordinate_t c2_new) { const float c1_noise = 10.0 + fabs(c1_cur+c1_new) / 20.0; // allow larger error for shapes far from the robot const float c2_noise = 10.0 + fabs(c2_cur+c2_new) / 20.0; return (c1_new-c1_noise < c1_cur && c2_cur < c2_new+c2_noise); } //! Update a line in the local map with info from a matching line in the ground space. bool LineData::updateParams(const ShapeRoot& ground_root, bool force) { const Shape<LineData>& ground_line = ShapeRootTypeConst(ground_root,LineData); // cout << "updating local Line " << getId() << " with data from ground line " << ground_line->getId() << ":" << endl; // ground_line->printEnds(); // cout << "Update from " << endl; // printEnds(); const coordinate_t c1_cur = firstPtCoord(); const coordinate_t c2_cur = secondPtCoord(); Point _end1_pt = firstPt(); Point _end2_pt = secondPt(); updateLinePt(firstPt(), firstPtCoord(), firstPt(ground_line), firstPtCoord(ground_line), -1); updateLinePt(secondPt(), secondPtCoord(), secondPt(ground_line), secondPtCoord(ground_line), +1); // cout << "to" << endl; // printEnds(); const coordinate_t c1_new = firstPtCoord(); const coordinate_t c2_new = secondPtCoord(); if (isValidUpdate(c1_cur, c2_cur, c1_new, c2_new) || force){ // cout << "was accepted, line updated" << endl; // ++nsamples; update_derived_properties(); return true; } // cout << "was denied, line not updated" << endl; setEndPts(_end1_pt, _end2_pt); return false; } void LineData::updateLinePt(EndPoint& localPt, coordinate_t local_coord, const EndPoint& groundPt, coordinate_t ground_coord, int sign) { if ( groundPt.isValid() ) { if ( localPt.isValid() ) localPt.updateParams(groundPt); else localPt = groundPt; } else if ( (ground_coord - local_coord)*sign > 0 ) localPt = groundPt; } bool LineData::isAdmissible() const { if (end1Pt().isValid() && end2Pt().isValid()) return length >= 70.0; // *** DST hack: lines should be at least 70 mm long else return length >= 40.0; } //! Print information about this shape. (Virtual in BaseData.) void LineData::printParams() const { cout << "Type = " << getTypeName() << " ID=" << getId() << " ParentID=" << getParentId() << endl; cout << " end1{" << end1Pt().coordX() << ", " << end1Pt().coordY() << "}" << " active=" << end1Pt().isActive() << " valid=" << end1Pt().isValid() << endl; cout << " end2{" << end2Pt().coordX() << ", " << end2Pt().coordY() << "}" << " active=" << end2Pt().isActive() << " valid=" << end2Pt().isValid() << std::endl; cout << " rho_norm=" << rho_norm << ", theta_norm=" << theta_norm << ", orientation=" << getOrientation() << ", length=" << getLength() << endl; printf(" color = %d %d %d\n",getColor().red,getColor().green,getColor().blue); cout << " mobile=" << getMobile() << ", viewable=" << isViewable() << endl; vector<float> abc = lineEquation_abc(); printf(" equ = %f %f %f\n",abc[0],abc[1],abc[2]); } void LineData::printEnds() const { cout << " end1{" << end1Pt().coordX() << ", " << end1Pt().coordY() << "}"; cout << " active=" << end1Pt().isActive() << ", valid=" << end1Pt().isValid() << endl; cout << " end2{" << end2Pt().coordX() << ", " << end2Pt().coordY() << "}"; cout << " active=" << end2Pt().isActive() << ", valid=" << end2Pt().isValid() << endl; // cout << endl; } // *** Transformations. *** // //! Apply a transformation to this shape. void LineData::applyTransform(const NEWMAT::Matrix& Tmat, const ReferenceFrameType_t newref) { end1Pt().applyTransform(Tmat,newref); end2Pt().applyTransform(Tmat,newref); update_derived_properties(); } void LineData::projectToGround(const NEWMAT::Matrix& camToBase, const NEWMAT::ColumnVector& groundplane) { end1Pt().projectToGround(camToBase,groundplane); end2Pt().projectToGround(camToBase,groundplane); update_derived_properties(); } // *** Logical endpoints *** // EndPoint& LineData::leftPt() { return end1Pt().isLeftOf(end2Pt()) ? end1_pt : end2_pt; } EndPoint& LineData::rightPt() { return end1Pt().isLeftOf(end2Pt()) ? end2_pt : end1_pt; } EndPoint& LineData::topPt() { return end1Pt().isAbove(end2Pt()) ? end1_pt : end2_pt; } EndPoint& LineData::bottomPt() { return end1Pt().isAbove(end2Pt()) ? end2_pt : end1_pt; } Shape<PointData> LineData::leftPtShape() { Shape<PointData> result(new PointData(*space, leftPt())); result->setName("leftPt"); result->inheritFrom(*this); result->setViewable(false); return result; } Shape<PointData> LineData::rightPtShape() { Shape<PointData> result(new PointData(*space, leftPt())); result->setName("rightPt"); result->inheritFrom(*this); result->setViewable(false); return result; } Shape<PointData> LineData::topPtShape() { Shape<PointData> result(new PointData(*space, leftPt())); result->setName("topPt"); result->inheritFrom(*this); result->setViewable(false); return result; } Shape<PointData> LineData::bottomPtShape() { Shape<PointData> result(new PointData(*space, leftPt())); result->setName("bottomPt"); result->inheritFrom(*this); result->setViewable(false); return result; } EndPoint& LineData::firstPt() { if ( isNotVertical() ) if ( end1Pt().coordX() < end2Pt().coordX() ) return end1Pt(); else return end2Pt(); else if ( end1Pt().coordY() < end2Pt().coordY() ) return end1Pt(); else return end2Pt(); } EndPoint& LineData::firstPt(const Shape<LineData> &otherline) const { if ( isNotVertical() ) if ( otherline->end1Pt().coordX() < otherline->end2Pt().coordX() ) return otherline->end1Pt(); else return otherline->end2Pt(); else if ( otherline->end1Pt().coordY() < otherline->end2Pt().coordY() ) return otherline->end1Pt(); else return otherline->end2Pt(); } EndPoint& LineData::secondPt() { if ( isNotVertical() ) if ( end1Pt().coordX() > end2Pt().coordX() ) return end1Pt(); else return end2Pt(); else if ( end1Pt().coordY() > end2Pt().coordY() ) return end1Pt(); else return end2Pt(); } EndPoint& LineData::secondPt(const Shape<LineData> &otherline) const { if ( isNotVertical() ) if ( otherline->end1Pt().coordX() > otherline->end2Pt().coordX() ) return otherline->end1Pt(); else return otherline->end2Pt(); else if ( otherline->end1Pt().coordY() > otherline->end2Pt().coordY() ) return otherline->end1Pt(); else return otherline->end2Pt(); } Shape<PointData> LineData::firstPtShape() { Shape<PointData> result(new PointData(*space, firstPt())); result->setName("firstPt"); result->inheritFrom(*this); result->setViewable(false); return result; } Shape<PointData> LineData::secondPtShape() { Shape<PointData> result(new PointData(*space, secondPt())); result->setName("secondPt"); result->inheritFrom(*this); result->setViewable(false); return result; } coordinate_t LineData::firstPtCoord() const { return isNotVertical() ? const_cast<LineData*>(this)->firstPt().coordX() : const_cast<LineData*>(this)->firstPt().coordY(); } coordinate_t LineData::firstPtCoord(const Shape<LineData> &otherline) const { return isNotVertical() ? firstPt(otherline).coordX() : firstPt(otherline).coordY(); } coordinate_t LineData::secondPtCoord() const { return isNotVertical() ? const_cast<LineData*>(this)->secondPt().coordX() : const_cast<LineData*>(this)->secondPt().coordY(); } coordinate_t LineData::secondPtCoord(const Shape<LineData> &otherline) const { return isNotVertical() ? secondPt(otherline).coordX() : secondPt(otherline).coordY(); } // *** Functions to set endpoints. *** // void LineData::setEndPts(const EndPoint& _end1_pt, const EndPoint& _end2_pt) { end1_pt.setCoords(_end1_pt); end1_pt.setActive(_end1_pt.isActive()); end1_pt.setValid(_end1_pt.isValid()); end1_pt.setNumUpdates(_end1_pt.numUpdates()); end2_pt.setCoords(_end2_pt); end2_pt.setActive(_end2_pt.isActive()); end2_pt.setValid(_end2_pt.isValid()); end2_pt.setNumUpdates(_end2_pt.numUpdates()); update_derived_properties(); } // *** Properties functions. *** // std::pair<float,float> LineData::lineEquation_mb() const { float m; if ((fabs(end2Pt().coordX() - end1Pt().coordX()) * BIG_SLOPE) <= fabs(end2Pt().coordY() - end2Pt().coordY())) m = BIG_SLOPE; else m = (end2Pt().coordY() - end1Pt().coordY())/(end2Pt().coordX() - end1Pt().coordX()); float b = end1Pt().coordY() - m * end1Pt().coordX(); return pair<float,float>(m,b); } //! Determine parameters a, b, c, d satisfying the equation ax + bz = c. std::vector<float> LineData::lineEquation_abc_xz() const { float dx = end2Pt().coordX() - end1Pt().coordX(); float dz = end2Pt().coordZ() - end1Pt().coordZ(); std::vector<float> abc; abc.resize(3, 1.0); float& a = abc[0]; float& b = abc[1]; float& c = abc[2]; // If vertical...b = 0 if((dx == 0.0) || (dz/dx > BIG_SLOPE)) { a = 1.0; b = 0.0; c = end1Pt().coordX(); } // If horizontal...a = 0 else if((dz == 0.0) || (dx/dz > BIG_SLOPE)) { a = 0.0; b = 1.0; c = end1Pt().coordZ(); } // If not horizontal or vertical...a = 1.0 else { a = 1.0; b = (end1Pt().coordX() - end2Pt().coordX()) / (end2Pt().coordZ() - end1Pt().coordZ()); c = end1Pt().coordX() + b*end1Pt().coordZ(); } return(abc); } //! Determine parameters a, b, c satisfying the equation ax + by = c. std::vector<float> LineData::lineEquation_abc() const { float dx = end2Pt().coordX() - end1Pt().coordX(); float dy = end2Pt().coordY() - end1Pt().coordY(); std::vector<float> abc; abc.resize(3, 1.0); float& a = abc[0]; float& b = abc[1]; float& c = abc[2]; // If vertical...b = 0 if( fabs(dx) < 1.0e-6 || dy/dx > BIG_SLOPE) { a = 1.0; b = 0.0; c = end1Pt().coordX(); } // If horizontal...a = 0 else if ( fabs(dy) < 1.0e-6 || dx/dy > BIG_SLOPE ) { a = 0.0; b = 1.0; c = end1Pt().coordY(); } // If not horizontal or vertical...a = 1.0 else { a = 1.0; // b = (end1Pt().coordX() - end2Pt().coordX()) // / (end2Pt().coordY() - end1Pt().coordY()); b = -dx / dy; c = end1Pt().coordX() + b*end1Pt().coordY(); } return(abc); } // *** Functions to set values dealing with orientation. *** // void LineData::update_derived_properties() { rho_norm = perpendicularDistanceFrom(origin_pt); const vector<float> abc = lineEquation_abc(); const float& a1 = abc[0]; const float& b1 = abc[1]; const float& c1 = abc[2]; const float c1sign = (c1 >= 0) ? 1.0 : -1.0; theta_norm = atan2(b1*c1sign, a1*c1sign); orientation = theta_norm + AngPi(M_PI/2); length = end1Pt().distanceFrom(end2Pt()); const ReferenceFrameType_t ref = getRefFrameType(); end1_pt.setRefFrameType(ref); end2_pt.setRefFrameType(ref); deleteRendering(); } bool LineData::isNotVertical() const { const AngPi threshold = M_PI / 3; const AngPi orient = getOrientation(); return (orient <= threshold) || (orient >= M_PI - threshold); } /* bool LineData::isRoughlyPerpendicularTo(Shape<LineData>& other) { AngPi threshold = M_PI_4; AngPi orientation_diff = getOrientation() - other->getOrientation(); if((orientation_diff >= threshold) && (orientation_diff < (M_PI-threshold))) return true; else return false; } bool LineData::isExactlyPerpendicularTo(Shape<LineData>& other) { AngPi orientation_diff = getOrientation() - other->getOrientation(); return (orientation_diff == M_PI_2); } */ // *** These functions are true based on line length. *** // bool LineData::isLongerThan(const Shape<LineData>& other) const { return length > other->length; } bool LineData::isLongerThan(float ref_length) const { return length > ref_length; } bool LineData::isShorterThan(const Shape<LineData>& other) const { return length < other->length; } bool LineData::isShorterThan(float ref_length) const { return length < ref_length; } bool LineData::isBetween(const Point &p, const LineData &other) const { if (getOrientation() == other.getOrientation()) { // parallel lines float dl = perpendicularDistanceFrom(other.end1Pt()); // distance between the lines return (perpendicularDistanceFrom(p) <= dl && other.perpendicularDistanceFrom(p) <= dl); } else { bool b; const LineData p_line (*space, p, // line from intersection of this and other to p intersectionWithLine(other, b, b)); const AngPi theta_pline = p_line.getOrientation(); const AngPi theta_greater = (getOrientation() > other.getOrientation()) ? getOrientation() : other.getOrientation(); const AngPi theta_smaller = (getOrientation() < other.getOrientation()) ? getOrientation() : other.getOrientation(); if (theta_greater - theta_smaller > M_PI/2) return (theta_pline >= theta_greater || theta_pline <= theta_smaller); else return (theta_pline <= theta_greater && theta_pline >= theta_smaller); } } // *** Check intersection. *** // bool LineData::intersectsLine(const Shape<LineData>& other) const { return intersectsLine(other.getData()); } bool LineData::intersectsLine(const LineData& other) const { // Calculate F(x,y) = 0 for this line (x1,y1) to (x2,y2). pair<float,float> F = lineEquation_mb(); // Calculate G(x,y) = 0 for L (x3,y3) to (x4,y4). pair<float,float> G = other.lineEquation_mb(); // NOTE: These tests are assumed to be taking place in the space of // "this" line. Therefore, the limits of line extent (for lines // with inactive endpoints) are calculated in the space of "this" // line. // JJW *** YOU NEED TO TAKE ACCOUNT OF END POINTS BEING TURNED OFF. // float end1x, end1y, end2x, end2y, other_end1x, other_end1y, other_end2x, other_end2y; // if(end1Pt().isActive()) { // end1x = end1Pt().coordX(); // end1y = end1Pt().coordY(); // } else { // end1x = // TEST 1 // Calculate r3 = F(x3,y3) float r3 = F.first * other.end1Pt().coordX() + F.second - other.end1Pt().coordY(); // Calculate r4 = F(x4,y4) float r4 = F.first * other.end2Pt().coordX() + F.second - other.end2Pt().coordY(); // If r3 != 0... // ...AND r4 != 0... // ...AND SGN(r3) == SGN(r4)... // ...THEN the lines do not intersect. if((r3 != 0) && (r4 != 0) && (SGN(r3) == SGN(r4)) ) return false; // TEST 2 // Calculate r1 = G(x1,y1) float r1 = G.first * end1Pt().coordX() + G.second - end1Pt().coordY(); // Calculate r2 = G(x2,y2) float r2 = G.first * end2Pt().coordX() + G.second - end2Pt().coordY(); // If r1 != 0... // ...AND r2 != 0... // ...AND SGN(r1) == SGN(r2)... // ...THEN the lines do not intersect. if((r1 != 0) && (r2 != 0) && (SGN(r1) == SGN(r2)) ) return false; // Otherwise, the lines DO intersect. return true; } Point LineData::intersectionWithLine(const Shape<LineData>& other, bool& intersection_on_this, bool& intersection_on_other) const { return intersectionWithLine(other.getData(), intersection_on_this,intersection_on_other); } Point LineData::intersectionWithLine(const LineData& other, bool& intersection_on_this, bool& intersection_on_other) const { // Based upon algorithm written by Paul Bourke, April 1989. // http://astronomy.swin.edu/~pbourke/geometry/lineline2d/ // Accessed July 20th 2004 // Points 1 and 2 are on "this" line. Points 3 and 4 define the "other" line. // float x1, x2, x3, x4, y1, y2, y3, y4; float x1, x2, x3, x4, y1, y2, y3, y4; x1 = end1Pt().coordX(); x2 = end2Pt().coordX(); x3 = other.end1Pt().coordX(); x4 = other.end2Pt().coordX(); // x3 = other->end1Pt().coordX(); // x4 = other->end2Pt().coordX(); y1 = end1Pt().coordY(); y2 = end2Pt().coordY(); y3 = other.end1Pt().coordY(); y4 = other.end2Pt().coordY(); // y3 = other->end1Pt().coordY(); // y4 = other->end2Pt().coordY(); // x1 + u_a(x2-x1) = x3 + u_b(x4-x3) // y1 + u_a(y2-y1) = y3 + u_b(y4-y3) // u_a = (x4-x3)(y1-y3) - (y4-y3)(x1-x3) // ------------------------------- // (y4-y3)(x2-x1) - (x4-x3)(y2-y1) // u_b = (x2-x1)(y1-y3) - (y2-y1)(x1-x3) // ------------------------------- // (y4-y3)(x2-x1) - (x4-x3)(y2-y1) float denom = ((y4-y3)*(x2-x1) - (x4-x3)*(y2-y1)); float u_a_numerator = ((x4-x3)*(y1-y3) - (y4-y3)*(x1-x3)); float u_b_numerator = ((x2-x1)*(y1-y3) - (y2-y1)*(x1-x3)); // If denominators of u_a and u_b are zero, then lines are parallel. if(denom == 0.0) { if (u_a_numerator == 0.0 && u_b_numerator == 0.0) { PRINTF("intersectionWithLine: lines are coincident!\n"); return(end1Pt()); } else { cout << x1 << " " << x2 << " " << x3 << " " << x4 << " " << y1 << " " << y2 << " " << y3 << " " << y4 << endl; cout << "this theta; " << getOrientation() << ", other theta: " << other.getOrientation() << endl; PRINTF("ERROR in intersectionWithLine: lines are parallel!\n"); return(Point(-9999.0,-99999.0)); } } else { float u_a = u_a_numerator / denom; float u_b = u_b_numerator / denom; // If 0 <= u_a <=1 then intersection point is on segment a. if(0.0 <= u_a <=1.0) intersection_on_this = true; else intersection_on_this = false; // If 0 <= u_b <=1 then intersection point is on segment b. if(0.0 <= u_b <=1.0) intersection_on_other = true; else intersection_on_other = false; return(Point((x1+u_a*(x2-x1)), (y1+u_a*(y2-y1)))); } } // *** Distance. *** // float LineData::perpendicularDistanceFrom(const Point& otherPt) const { // NOTE that this formula is rather slow, as it involves the // calculation of the line equation in addition to a square root here. // Using the formula from http://www.tpub.com/math2/8.htm vector<float> abc = lineEquation_abc(); float& a = abc[0]; float& b = abc[1]; float& c = abc[2]; // Distance... // (x*A + y*B - C ) // abs(------------- ) // (sqrt(a^2 + b^2)) float d = fabs((a * otherPt.coordX() + b * otherPt.coordY() - c)/sqrt(a*a + b*b)); // cout << "abcd: " << a << ", " << b << ", " << c << ", " << d << endl; return(d); } // ================================================== // BEGIN LINE EXTRACTION CODE // ================================================== #define BEG_DIST_THRESH 2 #define END_DIST_THRESH 2 Shape<LineData> LineData::extractLine(Sketch<bool>& sketch) { NEW_SKETCH_N(fatmask,bool,visops::fillin(sketch,1,2,8)); NEW_SKETCH_N(skel,bool,visops::skel(fatmask)); return extractLine(skel, sketch); } Shape<LineData> LineData::extractLine(Sketch<bool>& skeleton, const Sketch<bool>& occlusions) { const int width = skeleton->getWidth(), height = skeleton->getHeight(); SketchSpace &SkS = skeleton->getSpace(); ShapeSpace &ShS = SkS.getDualSpace(); // approximate largest skel region with line NEW_SKETCH_N(labels,uint,visops::oldlabelcc(skeleton,visops::EightWayConnect)); list<Region> regions = Region::extractRegions(labels,EXTRACT_LINE_MIN_AREA); if ( regions.empty() ) { ShapeRoot invalid; // need to define a named variable to avoid warning on next line return ShapeRootType(invalid,LineData); } Region skelchunk = regions.front(); // regions not empty, so use the largest.... AngPi orientation(skelchunk.findPrincipalAxisOrientation()); Point centroid(skelchunk.findCentroid()); // cout << " orientation=" << orientation << " centroid=" << centroid.getCoords() << endl; if (! skelchunk.isContained(centroid, 3) ) { // region does not look like a straight line Shape<LineData> result(splitLine(ShS, skelchunk, skeleton, occlusions)); if ( result.isValid() ) return result; } // Create a symbolic line object. Shape<LineData> extracted_line(ShS, centroid, orientation); extracted_line->setColor(skeleton->getColor()); extracted_line->setParentId(skeleton->getViewableId()); // rho and theta describe the normal line. // normpoint is where the normal line intersects with this line. // normpoint may actually be off-image. float x_normpoint = extracted_line->rho_norm*cos(extracted_line->theta_norm); float y_normpoint = extracted_line->rho_norm*sin(extracted_line->theta_norm); // m is slope of this line (not the normal line) // float m = (y_normpoint != 0) ? -(x_normpoint/y_normpoint) : BIG_SLOPE; float m = max(min(tan(extracted_line->theta_norm+AngPi(M_PI/2)), (float)BIG_SLOPE), (float)(-BIG_SLOPE)); float b = y_normpoint - m*x_normpoint; // cout << " x_normpoint=" << x_normpoint << " y_normpoint=" << y_normpoint // << " m=" << m << " b=" << b <<std::endl; NEW_SKETCH_N(skelDist,uint,visops::edist(skeleton)); if ( abs(m) <= 1 ) // when |slope| <= 1, scan along x, else scan along y extracted_line->scanHorizForEndPts(skelDist,occlusions,m,b); else extracted_line->scanVertForEndPts(skelDist,occlusions,m,b); // Check to see if any endpoints are near any edge of the screen. // If they are, invalidate them, assuming that line continues beyond screen. extracted_line->end1_pt.checkValidity(width,height,BEG_DIST_THRESH); extracted_line->end2_pt.checkValidity(width,height,BEG_DIST_THRESH); // Transform from SketchSpace coordinates to ShapeSpace coordinates SkS.applyTmatinv(extracted_line->end1_pt.getCoords()); SkS.applyTmatinv(extracted_line->end2_pt.getCoords()); extracted_line->update_derived_properties(); return extracted_line; } // hack to split a non-straight region by kei