Ejemplo n.º 1
0
        /// call edgeDrop on each cutter and pick the correct (highest valid CL-point) result

        //********   edge **************************************************** */
//C++ TO C# CONVERTER WARNING: 'const' methods are not available in C#:
//ORIGINAL LINE: bool edgeDrop(CLPoint &cl, const Triangle &t) const
        public new bool edgeDrop(CLPoint cl, Triangle t)
        {
            bool result = false;

            for (int n = 0; n < cutter.Count; ++n)
            {             // loop through cutters
                CLPoint cl_tmp = cl + new Point(0, 0, zoffset[n]);
                CCPoint cc_tmp;
                if (cutter[n].edgeDrop(cl_tmp, t))
                {                 // drop sub-cutter against edge
                    if (ccValidRadius(n, cl_tmp))
                    {             // check if cc-point is valid
                        cc_tmp = new CCPoint(cl_tmp.cc);
                        if (cl.liftZ(cl_tmp.z - zoffset[n]))
                        {                         // we need to lift the cutter
                            cc_tmp.type = CCType.EDGE;
                            cl.cc       = cc_tmp;
                            result      = true;
                        }
                        else
                        {
                            if (cc_tmp != null)
                            {
                                cc_tmp.Dispose();
                            }
                        }
                    }
                }
            }
            return(result);
        }
Ejemplo n.º 2
0
        /// first simple implementation of this operation

        // use OpenMP to share work between threads
        protected void pointDropCutter1(CLPoint clp)
        {
            nCalls = 0;
            int calls = 0;
            LinkedList <Triangle> tris;

            //tris=new std::list<Triangle>();
            tris = root.search_cutter_overlap(cutter, clp);
            LinkedList <Triangle> .Enumerator it;
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
            for (it = tris.GetEnumerator(); it != tris.end(); ++it)
            {             // loop over found triangles
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
                if (cutter.overlaps(clp, it))
                {                 // cutter overlap triangle? check
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
                    if (clp.below(it))
                    {
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
                        cutter.dropCutter(clp, it);
                        ++calls;
                    }
                }
            }

            /*
             *          delete(tris);
             */
            nCalls = calls;
            return;
        }
Ejemplo n.º 3
0
        /// \brief drop the MillingCutter at Point cl down along the z-axis until it makes contact with Triangle t.
        /// This function calls vertexDrop, facetDrop, and edgeDrop to do its job.
        /// Follows the template-method, or "self-delegation" design pattern.
        /// if cl.z is too low, updates cl.z so that the cutter does not cut Triangle t.

        // call vertex, facet, and edge drop methods on input Triangle t
//C++ TO C# CONVERTER WARNING: 'const' methods are not available in C#:
//ORIGINAL LINE: bool dropCutter(CLPoint &cl, const Triangle &t) const
        public bool dropCutter(CLPoint cl, Triangle t)
        {
            bool facet  = false;
            bool vertex = false;
            bool edge   = false;

            /* // alternative ordering of the tests:
             * if (cl.below(t))
             *  vertexDrop(cl,t);
             *
             * // optimisation: if we are now above the triangle we don't need facet and edge
             * if ( cl.below(t) ) {
             *  facetDrop(cl,t);
             *  edgeDrop(cl,t);
             * }*/

            if (cl.below(t))
            {
                facet = facetDrop(cl, t); // if we make contact with the facet...
                if (!facet)
                {                         // ...then we will not hit an edge/vertex, so don't check for that
                    vertex = vertexDrop(cl, t);
                    if (cl.below(t))
                    {
                        edge = edgeDrop(cl, t);
                    }
                }
            }

            return(facet || vertex || edge);
        }
Ejemplo n.º 4
0
        /// return true if cl.cc is within the radial range of cutter n
        /// for cutter n the valid radial distance from cl is
        /// between radiusvec[n-1] and radiusvec[n]
//C++ TO C# CONVERTER WARNING: 'const' methods are not available in C#:
//ORIGINAL LINE: bool ccValidRadius(uint n, CLPoint& cl) const
        protected bool ccValidRadius(int n, CLPoint cl)
        {
            if (cl.cc.type == CCType.NONE)
            {
                return(false);
            }
            double d = cl.xyDistance(cl.cc);
            double lolimit;
            double hilimit;

            if (n == 0)
            {
                lolimit = -1E-6;
            }
            else
            {
                lolimit = radiusvec[n - 1] - 1E-6;
            }
            hilimit = radiusvec[n] + 1e-6;             // FIXME: really ugly solution this one...
            if (d < lolimit)
            {
                return(false);
            }
            else if (d > hilimit)
            {
                return(false);
            }
            else
            {
                return(true);
            }
        }
Ejemplo n.º 5
0
        /// \brief drop cutter at (cl.x, cl.y) against facet of Triangle t
        /// calls xy_normal_length(), normal_length(), and center_height() on the subclass.
        /// if cl.z is too low, updates cl.z so that cutter does not cut the facet.
        /// CompositeCutter may be the only sub-class that needs to reimplement this function.

        // general purpose facet-drop which calls xy_normal_length(), normal_length(),
        // and center_height() on the subclass
//C++ TO C# CONVERTER WARNING: 'const' methods are not available in C#:
//ORIGINAL LINE: virtual bool facetDrop(CLPoint &cl, const Triangle &t) const
        public virtual bool facetDrop(CLPoint cl, Triangle t)
        {                                           // Drop cutter at (cl.x, cl.y) against facet of Triangle t
            Point normal = t.upNormal();            // facet surface normal

            if (GlobalMembers.isZero_tol(normal.z)) // vertical surface
            {
                return(false);                      //can't drop against vertical surface
            }
            Debug.Assert(GlobalMembers.isPositive(normal.z));

            if ((GlobalMembers.isZero_tol(normal.x)) && (GlobalMembers.isZero_tol(normal.y)))
            {             // horizontal plane special case
                CCPoint cc_tmp = new CCPoint(cl.x, cl.y, t.p[0].z, CCType.FACET);
                return(cl.liftZ_if_inFacet(cc_tmp.z, cc_tmp, t));
            }
            else
            {             // general case
                // plane containing facet:  a*x + b*y + c*z + d = 0, so
                // d = -a*x - b*y - c*z, where  (a,b,c) = surface normal
                double d = -normal.dot(t.p[0]);
                normal.normalize();                 // make length of normal == 1.0
                Point xyNormal = new Point(normal.x, normal.y, 0.0);
                xyNormal.xyNormalize();
                // define the radiusvector which points from the cc-point to the cutter-center
                Point   radiusvector = this.xy_normal_length * xyNormal + this.normal_length * normal;
                CCPoint cc_tmp       = new CCPoint(cl - radiusvector);                             // NOTE xy-coords right, z-coord is not.
                cc_tmp.z    = (1.0 / normal.z) * (-d - normal.x * cc_tmp.x - normal.y * cc_tmp.y); // cc-point lies in the plane.
                cc_tmp.type = CCType.FACET;
                double tip_z = cc_tmp.z + radiusvector.z - this.center_height;
                return(cl.liftZ_if_inFacet(tip_z, cc_tmp, t));
            }
        }
Ejemplo n.º 6
0
        /// CompositeCutter can not use the base-class facetDrop, instead we here
        /// call facetDrop() on each cutter in turn, and pick the valid CC/CL point
        /// as the result for the CompositeCutter

        //********   facetDrop  ********************** */

        // call facetDrop on each cutter and pick a valid cc-point
//C++ TO C# CONVERTER WARNING: 'const' methods are not available in C#:
//ORIGINAL LINE: bool facetDrop(CLPoint &cl, const Triangle &t) const
        public new bool facetDrop(CLPoint cl, Triangle t)
        {
            bool result = false;

            for (int n = 0; n < cutter.Count; ++n)
            {             // loop through cutters
                CLPoint cl_tmp = cl + new CLPoint(0, 0, zoffset[n]);
                CCPoint cc_tmp;
                if (cutter[n].facetDrop(cl_tmp, t))
                {
                    Debug.Assert(cl_tmp.cc != null);
                    if (ccValidRadius(n, cl_tmp))
                    {                     // cc-point is valid
                        cc_tmp = new CCPoint(cl_tmp.cc);
                        if (cl.liftZ(cl_tmp.z - zoffset[n]))
                        {                         // we need to lift the cutter
                            cc_tmp.type = CCType.FACET;
                            cl.cc       = cc_tmp;
                            result      = true;
                        }
                        else
                        {
                            if (cc_tmp != null)
                            {
                                cc_tmp.Dispose();
                            }
                        }
                    }
                }
            }
            return(result);
        }
Ejemplo n.º 7
0
        /// search for overlap with a MillingCutter c positioned at cl, return found objects
        public LinkedList <Triangle> search_cutter_overlap(MillingCutter c, CLPoint cl)
        {
            double r = c.getRadius();
            // build a bounding-box at the current CL
            Bbox bb = new Bbox(cl.x - r, cl.x + r, cl.y - r, cl.y + r, cl.z, cl.z + c.getLength());

            return(this.search(bb));
        }
        /// flatness predicate for adaptive sampling
        protected bool flat(CLPoint start_cl, CLPoint mid_cl, CLPoint stop_cl)
        {
            CLPoint v1 = new CLPoint(mid_cl - start_cl);
            CLPoint v2 = new CLPoint(stop_cl - mid_cl);

            v1.normalize();
            v2.normalize();
            return(v1.dot(v2) > cosLimit);
        }
Ejemplo n.º 9
0
        /// \brief call dropCutter on all Triangles in an STLSurf
        /// drops the MillingCutter at Point cl down along the z-axis
        /// until it makes contact with a triangle in the STLSurf s
        /// NOTE: no kd-tree optimization, this function will make
        /// dropCutter() calls for each and every Triangle in s.
        /// NOTE: should not really be used for real work, demo/debug only

        // TESTING ONLY, don't use for real
//C++ TO C# CONVERTER WARNING: 'const' methods are not available in C#:
//ORIGINAL LINE: bool dropCutterSTL(CLPoint &cl, const STLSurf &s) const
        public bool dropCutterSTL(CLPoint cl, STLSurf s)
        {
            bool result = false;

            foreach (Triangle t in s.tris)
            {
                if (this.dropCutter(cl, t))
                {
                    result = true;
                }
            }
            return(result);
        }
Ejemplo n.º 10
0
        /// 2nd version of algorithm

        /// push-cutter which uses KDNode2 kd-tree search to find triangles
        /// overlapping with the cutter.
        protected void pushCutter2()
        {
            // std::cout << "BatchPushCutter2 with " << fibers->size() <<
            //           " fibers and " << surf->tris.size() << " triangles..." << std::endl;
            nCalls = 0;
            LinkedList <Triangle> overlap_triangles;

            /*
             *          boost::progress_display show_progress = new boost::progress_display(fibers.Count);
             */
            foreach (Fiber f in fibers)
            {
                CLPoint cl = new CLPoint();
                if (x_direction)
                {
                    cl.x = 0;
                    cl.y = f.p1.y;
                    cl.z = f.p1.z;
                }
                else if (y_direction)
                {
                    cl.x = f.p1.x;
                    cl.y = 0;
                    cl.z = f.p1.z;
                }
                else
                {
                    Debug.Assert(false);
                }
                overlap_triangles = root.search_cutter_overlap(cutter, cl);
                Debug.Assert(overlap_triangles.Count <= surf.size());                 // can't possibly find more triangles than in the STLSurf
                foreach (Triangle t in overlap_triangles)
                {
                    //if ( bb->overlaps( t.bb ) ) {
                    Interval i = new Interval();
                    cutter.pushCutter(f, i, t);
                    f.addInterval(i);
                    ++nCalls;
                    //}
                }

                /*
                 * delete(overlap_triangles);
                 ++show_progress;
                 */
            }
            // std::cout << "BatchPushCutter2 done." << std::endl;
            return;
        }
        /// run adaptive sampling
        protected void adaptive_sampling_run()
        {
            //std::cout << " apdc::adaptive_sampling_run()... ";

            clpoints.Clear();
            foreach (Span span in path.span_list)
            {             // this loop could run in parallel, since spans don't depend on eachother
                CLPoint start = new CLPoint(span.getPoint(0.0));
                CLPoint stop  = new CLPoint(span.getPoint(1.0));
                subOp[0].run(start);
                subOp[0].run(stop);
                clpoints.Add(start);
                adaptive_sample(span, 0.0, 1.0, new ocl.CLPoint(start), new ocl.CLPoint(stop));
            }
            //std::cout << " DONE clpoints.size()=" << clpoints.size() << "\n";
        }
Ejemplo n.º 12
0
        /// sample the span unfirormly with tolerance sampling

        // this samples the Span and pushes the corresponding sampled points to bdc
        private void sample_span(Span span)
        {
            Debug.Assert(sampling > 0.0);
            uint num_steps = (uint)(span.length2d() / sampling + 1);

            for (uint i = 0; i <= num_steps; i++)
            {
                double  fraction = (double)i / num_steps;
                Point   ptmp     = span.getPoint(fraction);
                CLPoint p        = new CLPoint(ptmp.x, ptmp.y, ptmp.z);
                p.z = minimumZ;
                subOp[0].appendPoint(p);
                if (p != null)
                {
                    p.Dispose();
                }
            }
        }
Ejemplo n.º 13
0
        /// \brief drop cutter at (cl.x, cl.y) against the three vertices of Triangle t.
        /// calls this->height(r) on the subclass of MillingCutter we are using.
        /// if cl.z is too low, updates cl.z so that cutter does not cut any vertex.

        // general purpose vertex-drop which delegates to this->height(r) of subclass
//C++ TO C# CONVERTER WARNING: 'const' methods are not available in C#:
//ORIGINAL LINE: bool vertexDrop(CLPoint &cl, const Triangle &t) const
        public bool vertexDrop(CLPoint cl, Triangle t)
        {
            bool result = false;

            foreach (Point p in t.p)
            {                                // test each vertex of triangle
                double q = cl.xyDistance(p); // distance in XY-plane from cl to p
                if (q <= radius)
                {                            // p is inside the cutter
                    CCPoint cc_tmp = new CCPoint(p, CCType.VERTEX);
                    if (cl.liftZ(p.z - this.height(q), cc_tmp))
                    {
                        result = true;
                    }
                }
            }
            return(result);
        }
Ejemplo n.º 14
0
        /// Cone facet-drop is special, since we can make contact with either the tip or the circular rim

        // because this checks for contact with both the tip and the circular edge it is hard to move to the base-class
        // we either hit the tip, when the slope of the plane is smaller than angle
        // or when the slope is steep, the circular edge between the cone and the cylindrical shaft
//C++ TO C# CONVERTER WARNING: 'const' methods are not available in C#:
//ORIGINAL LINE: bool facetDrop(CLPoint &cl, const Triangle &t) const
        public new bool facetDrop(CLPoint cl, Triangle t)
        {
            bool  result = false;
            Point normal = t.upNormal();            // facet surface normal

            if (GlobalMembers.isZero_tol(normal.z)) // vertical surface
            {
                return(false);                      //can't drop against vertical surface
            }

            if ((GlobalMembers.isZero_tol(normal.x)) && (GlobalMembers.isZero_tol(normal.y)))
            {                                                                         // horizontal plane special case
                CCPoint cc_tmp = new CCPoint(cl.x, cl.y, t.p[0].z, CCType.FACET_TIP); // so any vertex is at the correct height
                return(cl.liftZ_if_inFacet(cc_tmp.z, cc_tmp, t));
            }
            else
            {
                // define plane containing facet
                // a*x + b*y + c*z + d = 0, so
                // d = -a*x - b*y - c*z, where  (a,b,c) = surface normal
                double a = normal.x;
                double b = normal.y;
                double c = normal.z;
                double d = -normal.dot(t.p[0]);
                normal.xyNormalize();                 // make xy length of normal == 1.0
                // cylindrical contact point case
                // find the xy-coordinates of the cc-point
                CCPoint cyl_cc_tmp = new CCPoint(cl - radius * normal);
                cyl_cc_tmp.z = (1.0 / c) * (-d - a * cyl_cc_tmp.x - b * cyl_cc_tmp.y);
                double cyl_cl_z = cyl_cc_tmp.z - length;                 // tip positioned here
                cyl_cc_tmp.type = CCType.FACET_CYL;

                // tip contact with facet
                CCPoint tip_cc_tmp = new CCPoint(cl.x, cl.y, 0.0);
                tip_cc_tmp.z = (1.0 / c) * (-d - a * tip_cc_tmp.x - b * tip_cc_tmp.y);
                double tip_cl_z = tip_cc_tmp.z;
                tip_cc_tmp.type = CCType.FACET_TIP;

                result = result || cl.liftZ_if_inFacet(tip_cl_z, tip_cc_tmp, t);
                result = result || cl.liftZ_if_inFacet(cyl_cl_z, cyl_cc_tmp, t);
                return(result);
            }
        }
Ejemplo n.º 15
0
        // DROP-CUTTER
        /// drop cutter against edge p1-p2 at xy-distance d from cl
        /// translates to cl=(0,0) and rotates edge to be along x-axis
        /// for call to singleEdgeDropCanonical()

        // 1) translate the geometry so that in the XY plane cl = (0,0)
        // 2) rotate the p1-p2 edge so that a new edge u1-u2 lies along the x-axis
        // 3) call singleEdgeDropCanonical(), implemented in the sub-class.
        //    this returns the x-coordinate of the CC point and cl.z
        // 4) rotate/translate back to the original geometry
        // 5) update cl.z if required and if CC lies within the edge
        //
        // The edge test can be done in a "dual" geometry.
        // instead of testing the original cutter against an infinitely thin edge
        // we can test a virtual CylCutter with radius VR against an infinite ER-radius cylinder around the edge.
        // This reduces to a 2D problem in the XY plane, where section of the ER-radius cylinder is an ellipse.
        // in the general case CL lies on an offset ellipse with offset OR.
        // The general cases only applies for BullCutter(R1,R2) where R1 is the shaft radius
        // and R2 is the corner radius.
        // For CylCutter and BallCutter there are simple analytic solutions and an offset ellipse approach is not required.
        //
        // The dual problem for each cutter type is:
        //
        //      CylCutter(R): VR = R, ER = 0, OR=R  (the z-position of VR is the same as for CylCutter)
        //     BallCutter(R): VR = 0, ER = R, OR=0 (the z-position of VR is a distance R up from the tip of BallCutter)
        // BullCutter(R1,R2): VR=R1-R2, ER=R2, OR=R1-R2 (z-position of VR is a distance R2 up from the tip of BullCutter)
        //
        // cone: ??? (how is this an ellipse??)
        //
        // d is the distance from the p1-p2 line to cl, in the 2D XY plane
//C++ TO C# CONVERTER WARNING: 'const' methods are not available in C#:
//ORIGINAL LINE: bool singleEdgeDrop(CLPoint& cl, const Point& p1, const Point& p2, double d) const
        protected bool singleEdgeDrop(CLPoint cl, Point p1, Point p2, double d)
        {
            Point v   = p2 - p1;                  // vector along edge, from p1 -> p2
            Point vxy = new Point(v.x, v.y, 0.0); // XY projection

            vxy.xyNormalize();                    // normalized XY edge vector
            // figure out u-coordinates of p1 and p2 (i.e. x-coord in the rotated system)
            Point sc = cl.xyClosestPoint(p1, p2);

            Debug.Assert(((cl - sc).xyNorm() - d) < 1E-6);
            // edge endpoints in the new coordinate system, in these coordinates, CL is at origo
            Point u1 = new Point((p1 - sc).dot(vxy), d, p1.z);                     // d, the distance to line, is the y-coord in the rotated system
            Point u2 = new Point((p2 - sc).dot(vxy), d, p2.z);
            Tuple <double, double> contact = this.singleEdgeDropCanonical(u1, u2); // the subclass handles this
            CCPoint cc_tmp = new CCPoint(sc + contact.Item1 * vxy, CCType.EDGE);   // translate back into original coord-system

            cc_tmp.z_projectOntoEdge(p1, p2);
            // update cl.z if required, and the cc-point lies inside the p1-p2 edge.
            return(cl.liftZ_if_InsidePoints(contact.Item2, cc_tmp, p1, p2));
        }
        /// run adaptive sample on the given Span between t-values of start_t and stop_t
        protected void adaptive_sample(Span span, double start_t, double stop_t, CLPoint start_cl, CLPoint stop_cl)
        {
            double mid_t = start_t + (stop_t - start_t) / 2.0;             // mid point sample

            Debug.Assert(mid_t > start_t);
            Debug.Assert(mid_t < stop_t);
            CLPoint mid_cl = new CLPoint(span.getPoint(mid_t));

            //std::cout << " apdc sampling at " << mid_t << "\n";
            subOp[0].run(mid_cl);
            double fw_step = (stop_cl - start_cl).xyNorm();

            if ((fw_step > sampling) || ((!flat(start_cl, mid_cl, stop_cl)) && (fw_step > min_sampling)))
            {             // OR not flat, and not max sampling
                adaptive_sample(span, start_t, mid_t, new ocl.CLPoint(start_cl), new ocl.CLPoint(mid_cl));
                adaptive_sample(span, mid_t, stop_t, new ocl.CLPoint(mid_cl), new ocl.CLPoint(stop_cl));
            }
            else
            {
                clpoints.Add(stop_cl);
            }
        }
Ejemplo n.º 17
0
        /// use kd-tree search to find overlapping triangles
        protected void pushCutter2(Fiber f)
        {
            LinkedList <Triangle> .Enumerator it;           // for looping over found triangles
            LinkedList <Triangle> .Enumerator it_end;
            Interval i;
            LinkedList <Triangle> tris;
            CLPoint cl = new CLPoint();

            if (x_direction)
            {
                cl.x = 0;
                cl.y = f.p1.y;
                cl.z = f.p1.z;
            }
            else if (y_direction)
            {
                cl.x = f.p1.x;
                cl.y = 0;
                cl.z = f.p1.z;
            }
            tris   = root.search_cutter_overlap(cutter, cl);
            it_end = tris.end();
            for (it = tris.GetEnumerator(); it != it_end; ++it)
            {
                i = new Interval();
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
                cutter.pushCutter(f, i, it.Current);
                f.addInterval(i);
                ++nCalls;
                if (i != null)
                {
                    i.Dispose();
                }
            }

            /*
             *          delete(tris);
             */
        }
Ejemplo n.º 18
0
        /// \brief drop cutter at (cl.x, cl.y) against the three edges of input Triangle t.
        /// calls the sub-class MillingCutter::singleEdgeDrop on each edge
        /// if cl.z is too low, updates cl.z so that cutter does not cut any edge.

        // edge-drop function which calls the sub-class MillingCutter::singleEdgeDrop on each
        // edge of the input Triangle t.
//C++ TO C# CONVERTER WARNING: 'const' methods are not available in C#:
//ORIGINAL LINE: virtual bool edgeDrop(CLPoint &cl, const Triangle &t) const
        public virtual bool edgeDrop(CLPoint cl, Triangle t)
        {
            bool result = false;

            for (int n = 0; n < 3; n++)
            {                              // loop through all three edges
                int   start = n;           // index of the start-point of the edge
                int   end   = (n + 1) % 3; // index of the end-point of the edge
                Point p1    = t.p[start];
                Point p2    = t.p[end];
                if (!GlobalMembers.isZero_tol(p1.x - p2.x) || !GlobalMembers.isZero_tol(p1.y - p2.y))
                {
                    double d = cl.xyDistanceToLine(p1, p2);
                    if (d <= radius)                     // potential contact with edge
                    {
                        if (this.singleEdgeDrop(cl, p1, p2, d))
                        {
                            result = true;
                        }
                    }
                }
            }
            return(result);
        }
Ejemplo n.º 19
0
 /// run algorithm on a single input CLPoint
 public virtual void run(CLPoint cl)
 {
     Debug.Assert(false);
 }
Ejemplo n.º 20
0
        /// 3rd version of algorithm

        /// use kd-tree search to find overlapping triangles
        /// use OpenMP for multi-threading
        protected void pushCutter3()
        {
            // std::cout << "BatchPushCutter3 with " << fibers->size() <<
            //           " fibers and " << surf->tris.size() << " triangles." << std::endl;
            // std::cout << " cutter = " << cutter->str() << "\n";
            nCalls = 0;

            /*
             *          boost::progress_display show_progress = new boost::progress_display(fibers.Count);
             */
#if _OPENMP
            Console.Write("OpenMP is enabled");
            omp_set_num_threads(nthreads);
            //omp_set_nested(1);
#endif
            LinkedList <Triangle> .Enumerator it;           // for looping over found triabgles
            LinkedList <Triangle> .Enumerator it_end;
            Interval i;
            LinkedList <Triangle> tris;
            List <Fiber>          fiberr = fibers;
#if _WIN32                                  // OpenMP version 2 of VS2013 OpenMP need signed loop variable
            int n;                          // loop variable
            int Nmax = fibers.Count;        // the number of fibers to process
#else
            int  n;                         // loop variable
            uint Nmax = (uint)fibers.Count; // the number of fibers to process
#endif
            uint calls = 0;

            //C++ TO C# CONVERTER TODO TASK: There is no equivalent to most C++ 'pragma' directives in C#:
            //    #pragma omp parallel for schedule(dynamic) shared(calls, fiberr) private(n,i,tris,it,it_end)
            //#pragma omp parallel for shared( calls, fiberr) private(n,i,tris,it,it_end)
            for (n = 0; n < Nmax; ++n)
            {             // loop through all fibers
#if _OPENMP
                if (n == 0)
                {                 // first iteration
                    if (omp_get_thread_num() == 0)
                    {
                        Console.Write("Number of OpenMP threads = ");
                        Console.Write(omp_get_num_threads());
                        Console.Write("\n");
                    }
                }
#endif
                CLPoint cl = new CLPoint();                 // cl-point on the fiber
                if (x_direction)
                {
                    cl.x = 0;
                    cl.y = fiberr[n].p1.y;
                    cl.z = fiberr[n].p1.z;
                }
                else if (y_direction)
                {
                    cl.x = fiberr[n].p1.x;
                    cl.y = 0;
                    cl.z = fiberr[n].p1.z;
                }
                tris   = root.search_cutter_overlap(cutter, cl);
                it_end = tris.end();
                for (it = tris.GetEnumerator(); it != it_end; ++it)
                {                 // loop through the found overlapping triangles
                    //if ( bb->overlaps( it->bb ) ) {
                    // todo: optimization where method-calls are skipped if triangle bbox already in the fiber
                    i = new Interval();
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
                    cutter.pushCutter(fiberr[n], i, it.Current);
                    fiberr[n].addInterval(i);
                    ++calls;
                    if (i != null)
                    {
                        i.Dispose();
                    }
                    //}
                }

                /*
                 * delete(tris);
                 ++show_progress;
                 */
            } // OpenMP parallel region ends here

            this.nCalls = (int)calls;
            // std::cout << "\nBatchPushCutter3 done." << std::endl;
            return;
        }
Ejemplo n.º 21
0
 /// append to list of CL-points to evaluate
 public new void appendPoint(CLPoint p)
 {
     clpoints.Add(p);
 }
Ejemplo n.º 22
0
 /// add an input CLPoint to this Operation
 public virtual void appendPoint(CLPoint p)
 {
 }
Ejemplo n.º 23
0
 public new void run(CLPoint clp)
 {
     //std::cout << "PointDropCutter::run() clp= " << clp << " dropped to ";
     pointDropCutter1(clp);
     //std::cout  << clp << " nCalls = " << nCalls <<"\n ";
 }
Ejemplo n.º 24
0
 public override void addCLPoint(CLPoint p)
 {
     clpoints.AddLast(p);
 }