Ejemplo n.º 1
0
        public void CloseContour()
        {
            if (curX == latestMoveToX && curY == latestMoveToY)
            {
                //we not need to close
            }
            else
            {
                if (_latestPart != null)
                {
                    currentCnt.AddPart(_latestPart = new GlyphLine(_latestPart, latestMoveToX, latestMoveToY));
                }
                else
                {
                    currentCnt.AddPart(_latestPart = new GlyphLine(curX, curY, latestMoveToX, latestMoveToY));
                }
            }

            this.curX = latestMoveToX;
            this.curY = latestMoveToY;

            if (currentCnt != null &&
                currentCnt.parts.Count > 0)
            {
                this.contours.Add(currentCnt);
                currentCnt = null;
            }
            //
            currentCnt = new GlyphContour();
        }
Ejemplo n.º 2
0
        public void CloseContour()
        {
            if (_curX == _latestMoveToX && _curY == _latestMoveToY)
            {
                //we not need to close
            }
            else
            {
                if (_latestPart != null)
                {
                    _currentCnt.AddPart(_latestPart = new GlyphLine(_latestPart, _latestMoveToX, _latestMoveToY));
                }
                else
                {
                    _currentCnt.AddPart(_latestPart = new GlyphLine(_curX, _curY, _latestMoveToX, _latestMoveToY));
                }
            }

            _curX = _latestMoveToX;
            _curY = _latestMoveToY;

            if (_currentCnt != null &&
                _currentCnt.parts.Count > 0)
            {
                _contours.Add(_currentCnt);
                _currentCnt = null;
            }
            //
            _currentCnt = new GlyphContour();
        }
Ejemplo n.º 3
0
 public void BeginRead(int contourCount)
 {
     //reset all
     contours           = new List <GlyphContour>();
     _latestPart        = null;
     this.latestMoveToX = this.curX = this.latestMoveToY = this.curY = 0;
     //
     currentCnt = new GlyphContour();
     //new contour, but not add
 }
Ejemplo n.º 4
0
        void GenerateContourOutput(IGlyphTranslator tx, GlyphContour contour)
        {
            List <GlyphPoint> points = contour.flattenPoints;
            int j = points.Count;

            if (j == 0)
            {
                return;
            }
            //-------------------------------------------------
            Bounds controlBounds = this.OriginalGlyphControlBounds;
            //walk along the edge in the contour to generate new edge output
            float pxscale = this._pxScale;


#if DEBUG
            //            dbugWriteLine("===begin===" + fit_x_offset);
            //            if (!dbugUseHorizontalFitValue)
            //            {
            //                fit_x_offset = 0;
            //            }
#endif

            //-------------------------------------------------
            //fineSubPixelRenderingOffset = 0.33f;

            //-------------------------------------------------

            //TODO: review here
            float fit_x, fit_y;
            points[0].GetFitXY(pxscale, out fit_x, out fit_y);
            //
            tx.MoveTo(fit_x, fit_y);
#if DEBUG
            // dbugWriteOutput("M", fit_x, fit_x + fit_x_offset, fit_y);
#endif
            //2. others
            for (int i = 1; i < j; ++i)
            {
                //try to fit to grid
                points[i].GetFitXY(pxscale, out fit_x, out fit_y);
                tx.LineTo(fit_x, fit_y);
#if DEBUG
                //for debug
                //dbugWriteOutput("L", fit_x, fit_x + fit_x_offset, fit_y);
#endif
            }
            //close
            tx.CloseContour();
#if DEBUG
            //dbugWriteLine("===end===");
#endif
        }
Ejemplo n.º 5
0
        void CreateGlyphEdges()
        {
            //reset bounds
            _bounds_minX = _bounds_minY = float.MaxValue;
            _bounds_maxX = _bounds_maxY = float.MinValue;

            List <GlyphContour> contours = this._contours;
            int j = contours.Count;

            for (int i = 0; i < j; ++i)
            {
                GlyphContour cnt = contours[i];
                cnt.CreateGlyphEdges();
                //this is a new found after fitting process
                cnt.FindBounds(ref _bounds_minX, ref _bounds_minY, ref _bounds_maxX, ref _bounds_maxY);
            }
        }
Ejemplo n.º 6
0
        //
        public void Walk(GlyphDynamicOutline dynamicOutline)
        {
#if DEBUG
            _dynamicOutline = dynamicOutline;
            int triNumber = 0;
            if (WalkTrianglesAndEdges)
            {
                foreach (GlyphTriangle tri in _dynamicOutline.dbugGetGlyphTriangles())
                {
                    float centroidX, centriodY;
                    tri.CalculateCentroid(out centroidX, out centriodY);
                    OnTriangle(triNumber++, tri.e0, tri.e1, tri.e2, centroidX, centriodY);
                }
            }
            //---------------
            List <GlyphContour> contours = _dynamicOutline._contours;

            List <CentroidLineHub> centroidLineHubs = _dynamicOutline.dbugGetCentroidLineHubs();
            foreach (CentroidLineHub lineHub in centroidLineHubs)
            {
                Dictionary <GlyphTriangle, CentroidLine> lines = lineHub.GetAllCentroidLines();
                Vector2 hubCenter = lineHub.CalculateAvgHeadPosition();

                OnBegingLineHub(hubCenter.X, hubCenter.Y);
                foreach (CentroidLine line in lines.Values)
                {
                    List <GlyphBoneJoint> joints = line._joints;
                    int pairCount = joints.Count;

                    for (int i = 0; i < pairCount; ++i)
                    {
                        GlyphBoneJoint joint = joints[i];
                        if (WalkCentroidBone)
                        {
                            float px, py, qx, qy;
                            joint.dbugGetCentroidBoneCenters(out px, out py, out qx, out qy);
                            OnCentroidLine(px, py, qx, qy);
                            //--------------------------------------------------
                            if (joint.TipEdgeP != null)
                            {
                                Vector2 pos = joint.TipPointP;
                                OnCentroidLineTip_P(px, py, pos.X, pos.Y);
                            }
                            if (joint.TipEdgeQ != null)
                            {
                                Vector2 pos = joint.TipPointQ;
                                OnCentroidLineTip_Q(qx, qy, pos.X, pos.Y);
                            }
                        }
                        if (WalkGlyphBone)
                        {
                            OnBoneJoint(joint);
                        }
                    }
                    if (WalkGlyphBone)
                    {
                        //draw bone list
                        DrawBoneLinks(line);
                    }
                }
                //
                OnEndLineHub(hubCenter.X, hubCenter.Y, lineHub.GetHeadConnectedJoint());
            }
            //----------------

            List <GlyphContour> cnts = _dynamicOutline._contours;
            int j = cnts.Count;
            for (int i = 0; i < j; ++i)
            {
                GlyphContour      cnt    = cnts[i];
                List <GlyphPoint> points = cnt.flattenPoints;
                int n = points.Count;
                for (int m = 0; m < n; ++m)
                {
                    OnGlyphEdgeN(points[m].E0);
                }
            }
#endif
        }
Ejemplo n.º 7
0
        /// <summary>
        /// create GlyphDynamicOutline from flatten contours
        /// </summary>
        /// <param name="flattenContours"></param>
        /// <returns></returns>
        GlyphDynamicOutline CreateDynamicOutline(List <GlyphContour> flattenContours)
        {
            //--------------------------
            //TODO: review here, add hole or not
            // more than 1 contours, no hole => eg.  i, j, ;,  etc
            // more than 1 contours, with hole => eg.  a,e ,   etc

            //closewise => not hole
            _waitingHoles.Clear();
            int cntCount = flattenContours.Count;

            Poly2Tri.Polygon mainPolygon = null;
            //
            //this version if it is a hole=> we add it to main polygon
            //TODO: add to more proper polygon ***
            //eg i
            //--------------------------
            List <Poly2Tri.Polygon> otherPolygons = null;

            for (int n = 0; n < cntCount; ++n)
            {
                GlyphContour cnt = flattenContours[n];
                if (cnt.IsClosewise())
                {
                    //not a hole
                    if (mainPolygon == null)
                    {
                        //if we don't have mainPolygon before
                        //this is main polygon
                        mainPolygon = CreatePolygon(cnt.flattenPoints);

                        if (_waitingHoles.Count > 0)
                        {
                            //flush all waiting holes to the main polygon
                            int j = _waitingHoles.Count;
                            for (int i = 0; i < j; ++i)
                            {
                                mainPolygon.AddHole(_waitingHoles[i]);
                            }
                            _waitingHoles.Clear();
                        }
                    }
                    else
                    {
                        //if we already have a main polygon
                        //then this is another sub polygon
                        //IsHole is correct after we Analyze() the glyph contour
                        Poly2Tri.Polygon subPolygon = CreatePolygon(cnt.flattenPoints);
                        if (otherPolygons == null)
                        {
                            otherPolygons = new List <Poly2Tri.Polygon>();
                        }
                        otherPolygons.Add(subPolygon);
                    }
                }
                else
                {
                    //this is a hole
                    Poly2Tri.Polygon subPolygon = CreatePolygon(cnt.flattenPoints);
                    if (mainPolygon == null)
                    {
                        //add to waiting polygon
                        _waitingHoles.Add(subPolygon);
                    }
                    else
                    {
                        //add to mainPolygon
                        mainPolygon.AddHole(subPolygon);
                    }
                }
            }
            if (_waitingHoles.Count > 0)
            {
                throw new NotSupportedException();
            }
            //------------------------------------------
            //2. tri angulate
            Poly2Tri.P2T.Triangulate(mainPolygon); //that poly is triangulated

            Poly2Tri.Polygon[] subPolygons = (otherPolygons != null) ? otherPolygons.ToArray() : null;
            if (subPolygons != null)
            {
                for (int i = subPolygons.Length - 1; i >= 0; --i)
                {
                    Poly2Tri.P2T.Triangulate(subPolygons[i]);
                }
            }

            //3. intermediate outline is used inside this lib
            //and then convert intermediate outline to dynamic outline
            return(new GlyphDynamicOutline(
                       new GlyphIntermediateOutline(flattenContours, mainPolygon, subPolygons)));
        }