Changeset 11680 for OpenSceneGraph/trunk/examples/osgtext3D/osgtext3D.cpp

Timestamp:

07/19/10 22:34:15 (3 years ago)

Author:

robert

Message:

Added boundary bisector computation, bisector intersection thickness and segment removal.

Files:

• OpenSceneGraph/trunk/examples/osgtext3D/osgtext3D.cpp (modified) (10 diffs)

OpenSceneGraph/trunk/examples/osgtext3D/osgtext3D.cpp

@@ -32 +32 @@
 extern int main_test(int, char**);
 
+
+osg::Vec3 computeRayIntersectionPoint(const osg::Vec3& a, const osg::Vec3& an, const osg::Vec3& c, const osg::Vec3& cn)
+{
+    float denominator = ( cn.x() * an.y() - cn.y() * an.x());
+    if (denominator==0.0)
+    {
+        OSG_NOTICE<<"computeRayIntersectionPoint()<<denominator==0.0"<<std::endl;
+        // line segments must be parallel.
+        return (a+c)*0.5;
+    }
+
+    float t = ((a.x()-c.x())*an.y() - (a.y()-c.y())*an.x()) / denominator;
+    return c + cn*t;
+}
+
 osg::Vec3 computeIntersectionPoint(const osg::Vec3& a, const osg::Vec3& b, const osg::Vec3& c, const osg::Vec3& d)
 {
+#if 0
     float ba_x = b.x()-a.x();
     float ba_y = b.y()-a.y();
@@ -50 +66 @@
 
     return c + (d-c)*t;
+#endif
+    return computeRayIntersectionPoint(a, b-a, c, d-c);
+
 }
 
@@ -58 +77 @@
     float length_ab = ab.normalize();
     float length_dc = dc.normalize();
-    float denominator = (ab.x()-dc.x());
-    if (denominator==0.0)
-    {
-        // ab and cd parallel
-        return osg::Vec3(ab.y(), -ab.x(), 0.0f);
-    }
-    float r = (dc.x()-ab.y())/ denominator;
-    float ny = 1.0f / sqrtf(r*r + 1.0f);
-    float nx = r * ny;
-
-    return osg::Vec3(nx,ny,0.0f);
+
+    float e = dc.y() - ab.y();
+    float f = ab.x() - dc.x();
+    float denominator = sqrtf(e*e + f*f);
+    float nx = e / denominator;
+    float ny = f / denominator;
+    if (( ab.x()*ny - ab.y()*nx) > 0.0f)
+    {
+        // OSG_NOTICE<<"   computeBisectorNormal(a=["<<a<<"], b=["<<b<<"], c=["<<c<<"], d=["<<d<<"]), nx="<<nx<<", ny="<<ny<<", denominator="<<denominator<<" no need to swap"<<std::endl;
+        return osg::Vec3(nx,ny,0.0f);
+    }
+    else
+    {
+        OSG_NOTICE<<"   computeBisectorNormal(a=["<<a<<"], b=["<<b<<"], c=["<<c<<"], d=["<<d<<"]), nx="<<nx<<", ny="<<ny<<", denominator="<<denominator<<" need to swap!!!"<<std::endl;
+        return osg::Vec3(-nx,-ny,0.0f);
+    }
+}
+
+float computeBisectorIntersectorThickness(const osg::Vec3& a, const osg::Vec3& b, const osg::Vec3& c, const osg::Vec3& d, const osg::Vec3& e, const osg::Vec3& f)
+{
+    osg::Vec3 intersection_abcd = computeIntersectionPoint(a,b,c,d);
+    osg::Vec3 bisector_abcd = computeBisectorNormal(a,b,c,d);
+    osg::Vec3 intersection_cdef = computeIntersectionPoint(c,d,e,f);
+    osg::Vec3 bisector_cdef = computeBisectorNormal(c,d,e,f);
+    if (bisector_abcd==bisector_cdef)
+    {
+        OSG_NOTICE<<"computeBisectorIntersector(["<<a<<"], ["<<b<<"], ["<<c<<"], ["<<d<<"], ["<<e<<"], ["<<f<<"[)"<<std::endl;
+        OSG_NOTICE<<"   bisectors parallel, thickness = "<<FLT_MAX<<std::endl;
+        return FLT_MAX;
+    }
+
+    osg::Vec3 bisector_intersection = computeRayIntersectionPoint(intersection_abcd,bisector_abcd, intersection_cdef, bisector_cdef);
+    osg::Vec3 normal(d.y()-c.y(), c.x()-d.x(), 0.0);
+    float cd_length = normal.normalize();
+    if (cd_length==0)
+    {
+        OSG_NOTICE<<"computeBisectorIntersector(["<<a<<"], ["<<b<<"], ["<<c<<"], ["<<d<<"], ["<<e<<"], ["<<f<<"[)"<<std::endl;
+        OSG_NOTICE<<"   segment length==0, thickness = "<<FLT_MAX<<std::endl;
+        return FLT_MAX;
+    }
+
+    float thickness = (bisector_intersection - c) * normal;
+#if 0
+    OSG_NOTICE<<"computeBisectorIntersector(["<<a<<"], ["<<b<<"], ["<<c<<"], ["<<d<<"], ["<<e<<"], ["<<f<<"[)"<<std::endl;
+    OSG_NOTICE<<"   bisector_abcd = "<<bisector_abcd<<", bisector_cdef="<<bisector_cdef<<std::endl;
+    OSG_NOTICE<<"   bisector_intersection = "<<bisector_intersection<<", thickness = "<<thickness<<std::endl;
+#endif
+    return thickness;
 }
 
 class Boundary
 {
-    typedef std::vector<unsigned int>   Points;
-    typedef std::vector<float>          Distances;
-    typedef std::vector<osg::Vec3>      Bisectors;
-
-    struct Segment : public osg::Referenced
-    {
-        unsigned int            _p1;
-        unsigned int            _p2;
-        Segment*                _left;
-        osg::ref_ptr<Segment>   _right;
-        float                   _distance;
-    };
-
-    osg::ref_ptr<Segment>  _head;
-
+public:
+
+    typedef std::pair<unsigned int, unsigned int> Segment;
+    typedef std::vector<Segment>  Segments;
     osg::ref_ptr<osg::Vec3Array> _vertices;
-    Bisectors                   _bisectors;
-    Points                      _boundary;
-    Distances                   _distances;
+    Segments _segments;
+
+    Boundary(osg::Vec3Array* vertices, unsigned int start, unsigned int count)
+    {
+        _vertices = vertices;
+
+        if ((*_vertices)[start]==(*_vertices)[start+count-1])
+        {
+            OSG_NOTICE<<"Boundary is a line loop"<<std::endl;
+        }
+        else
+        {
+            OSG_NOTICE<<"Boundary is not a line loop"<<std::endl;
+        }
+
+        _segments.reserve(count-1);
+        for(unsigned int i=start; i<start+count-1; ++i)
+        {
+            _segments.push_back(Segment(i,i+1));
+        }
+
+    }
+
+    float computeThickness(unsigned int i)
+    {
+        Segment& seg_before = _segments[ (i+_segments.size()-1) % _segments.size() ];
+        Segment& seg_target = _segments[ (i) % _segments.size() ];
+        Segment& seg_after =  _segments[ (i+1) % _segments.size() ];
+        return computeBisectorIntersectorThickness(
+            (*_vertices)[seg_before.first], (*_vertices)[seg_before.second],
+            (*_vertices)[seg_target.first], (*_vertices)[seg_target.second],
+            (*_vertices)[seg_after.first], (*_vertices)[seg_after.second]);
+    }
+
+    void computeAllThickness()
+    {
+        for(unsigned int i=0; i<_segments.size(); ++i)
+        {
+            computeThickness(i);
+        }
+    }
+
+
+    bool findMinThickness(unsigned int& minThickness_i, float& minThickness)
+    {
+        minThickness_i = _segments.size();
+        for(unsigned int i=0; i<_segments.size(); ++i)
+        {
+            float thickness = computeThickness(i);
+            if (thickness>0.0 && thickness <  minThickness)
+            {
+                minThickness = thickness;
+                minThickness_i = i;
+            }
+        }
+
+        return minThickness_i != _segments.size();
+    }
+
+    void removeAllSegmentsBelowThickness(float targetThickness)
+    {
+        OSG_NOTICE<<"removeAllSegmentsBelowThickness("<<targetThickness<<")"<<std::endl;
+        for(;;)
+        {
+            unsigned int minThickness_i = _segments.size();
+            float minThickness = targetThickness;
+            if (!findMinThickness(minThickness_i,minThickness)) break;
+
+            OSG_NOTICE<<"  removing segment _segments["<<minThickness_i<<"] ("<<_segments[minThickness_i].first<<", "<<_segments[minThickness_i].second<<" with thickness="<<minThickness<<" "<<std::endl;
+            _segments.erase(_segments.begin()+minThickness_i);
+        }
+    }
+
 };
 
@@ -173 +288 @@
     osg::Vec3 bisector(v32-v21);
 
-
-    OSG_NOTICE<<"v1="<<v1<<", v2="<<v2<<", v3="<<v3<<", dot_angle="<<osg::RadiansToDegrees(angle)<<std::endl;
+#if 0
+    OSG_NOTICE<<"v1=["<<v1<<"], v2=["<<v2<<"], v3=["<<v3<<"], dot_angle="<<osg::RadiansToDegrees(angle)<<std::endl;
     OSG_NOTICE<<"     computeIntersectionPoint() point "<<computeIntersectionPoint(v1,v2,v2,v3)<<std::endl;
-    OSG_NOTICE<<"     computeBisectorNormal() normal "<<computeBisectorNormal(v1,v2,v2,v3)<<std::endl;
+#endif
+    // OSG_NOTICE<<"     computeBisectorNormal() normal "<<computeBisectorNormal(v1,v2,v2,v3)<<std::endl;
     
     if (bisector.length()<0.5)
@@ -190 +306 @@
         bisector.normalize();
 
-        OSG_NOTICE<<"     bisector normal "<<computeBisectorNormal(v1,v2,v2,v3)<<std::endl;
+        
+        if ((computeBisectorNormal(v1,v2,v2,v3)-bisector).length2()>0.001)
+        {
+            OSG_NOTICE<<"     WARNING 1 bisector disagree "<<bisector<<", s21=["<<s21<<"], s32=["<<s32<<"]"<<std::endl;
+        }
+        else
+        {
+#if 0
+            OSG_NOTICE<<"     bisector normal "<<bisector<<std::endl;
+#endif
+        }
 
         float l = t / sin(angle*0.5);
@@ -206 +332 @@
         if (cross.z()>0.0) bisector = -bisector;
 
-        OSG_NOTICE<<"     bisector normal "<<computeBisectorNormal(v1,v2,v2,v3)<<std::endl;
+        if ((computeBisectorNormal(v1,v2,v2,v3)-bisector).length2()>0.001)
+        {
+            OSG_NOTICE<<"     WARNING 2 bisector disagree "<<bisector<<std::endl;
+        }
+        else
+        {
+#if 0
+            OSG_NOTICE<<"     bisector normal "<<bisector<<std::endl;
+#endif
+        }
 
         osg::Vec3 new_vertex = v2 + bisector * l;
@@ -216 +351 @@
 osg::DrawArrays* computeBevelEdge(osg::Vec3Array& orig_vertices, unsigned int start, unsigned int count, osg::Vec3Array& new_vertices)
 {
-    OSG_NOTICE<<"computeBoundaryAngles("<<orig_vertices.size()<<", "<<start<<", "<<count<<")"<<std::endl;
+
+    OSG_NOTICE<<"computeBevelEdge("<<orig_vertices.size()<<", "<<start<<", "<<count<<")"<<std::endl;
     if (orig_vertices[start+count-1]==orig_vertices[start])
     {
@@ -271 +407 @@
 }
 
+osg::Geometry* computeThickness(osg::Geometry* orig_geometry, float thickness)
+{
+    OSG_NOTICE<<"computeThickness("<<orig_geometry<<")"<<std::endl;
+    osg::Vec3Array* orig_vertices = dynamic_cast<osg::Vec3Array*>(orig_geometry->getVertexArray());
+    osg::Geometry::PrimitiveSetList& orig_primitives = orig_geometry->getPrimitiveSetList();
+
+    for(osg::Geometry::PrimitiveSetList::iterator itr = orig_primitives.begin();
+        itr != orig_primitives.end();
+        ++itr)
+    {
+        osg::DrawArrays* drawArray = dynamic_cast<osg::DrawArrays*>(itr->get());
+        if (drawArray && drawArray->getMode()==GL_POLYGON)
+        {
+            Boundary boundary(orig_vertices, drawArray->getFirst(), drawArray->getCount());
+            boundary.computeAllThickness();
+
+            boundary.removeAllSegmentsBelowThickness(thickness);
+        }
+    }
+    return 0;
+}
+
+
 int main(int argc, char** argv)
 {
@@ -297 +456 @@
     bool useTessellator = false;
     while(arguments.read("-t") || arguments.read("--tessellate")) { useTessellator = true; }
+
+    float thickness = 5.0;
+    while(arguments.read("--thickness",thickness)) {}
 
     osg::ref_ptr<osg::Group> group = new osg::Group;
@@ -325 +487 @@
         geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
 
-        computeBoundaryAngles(geometry);
+        // computeBoundaryAngles(geometry);
 
         osg::Geometry* bevel = computeBevelEdge(geometry);
         geode->addDrawable(bevel);
+
+        computeThickness(geometry, thickness);
 
         if (useTessellator)