// Returns the number of styles
        public int sweep_styles()
        {
            for (;;)
            {
                if (m_scan_y > m_Rasterizer.max_y())
                {
                    return(0);
                }
                int       num_cells = (int)m_Rasterizer.scanline_num_cells(m_scan_y);
                cell_aa[] cells;
                int       cellOffset = 0;
                int       curCellOffset;
                m_Rasterizer.scanline_cells(m_scan_y, out cells, out cellOffset);
                int num_styles = (int)(m_max_style - m_min_style + 2);
                int style_id;
                int styleOffset = 0;

                m_cells.Allocate((int)num_cells * 2, 256); // Each cell can have two styles
                m_ast.Capacity(num_styles, 64);
                m_asm.Allocate((num_styles + 7) >> 3, 8);
                m_asm.zero();

                if (num_cells > 0)
                {
                    // Pre-add zero (for no-fill style, that is, -1).
                    // We need that to ensure that the "-1 style" would go first.
                    m_asm.Array[0] |= 1;
                    m_ast.add(0);
                    m_styles.Array[styleOffset].start_cell = 0;
                    m_styles.Array[styleOffset].num_cells  = 0;
                    m_styles.Array[styleOffset].last_x     = -0x7FFFFFFF;

                    m_sl_start = cells[0].x;
                    m_sl_len   = (int)(cells[num_cells - 1].x - m_sl_start + 1);
                    while (num_cells-- != 0)
                    {
                        curCellOffset = (int)cellOffset++;
                        add_style(cells[curCellOffset].left);
                        add_style(cells[curCellOffset].right);
                    }

                    // Convert the Y-histogram into the array of starting indexes
                    int          i;
                    int          start_cell  = 0;
                    style_info[] stylesArray = m_styles.Array;
                    for (i = 0; i < m_ast.size(); i++)
                    {
                        int IndexToModify = (int)m_ast[i];
                        int v             = stylesArray[IndexToModify].start_cell;
                        stylesArray[IndexToModify].start_cell = start_cell;
                        start_cell += v;
                    }

                    num_cells = (int)m_Rasterizer.scanline_num_cells(m_scan_y);
                    m_Rasterizer.scanline_cells(m_scan_y, out cells, out cellOffset);

                    while (num_cells-- > 0)
                    {
                        curCellOffset = (int)cellOffset++;
                        style_id      = (int)((cells[curCellOffset].left < 0) ? 0 :
                                              cells[curCellOffset].left - m_min_style + 1);

                        styleOffset = (int)style_id;
                        if (cells[curCellOffset].x == stylesArray[styleOffset].last_x)
                        {
                            cellOffset = stylesArray[styleOffset].start_cell + stylesArray[styleOffset].num_cells - 1;
                            unchecked
                            {
                                cells[cellOffset].area  += cells[curCellOffset].area;
                                cells[cellOffset].cover += cells[curCellOffset].cover;
                            }
                        }
                        else
                        {
                            cellOffset                      = stylesArray[styleOffset].start_cell + stylesArray[styleOffset].num_cells;
                            cells[cellOffset].x             = cells[curCellOffset].x;
                            cells[cellOffset].area          = cells[curCellOffset].area;
                            cells[cellOffset].cover         = cells[curCellOffset].cover;
                            stylesArray[styleOffset].last_x = cells[curCellOffset].x;
                            stylesArray[styleOffset].num_cells++;
                        }

                        style_id = (int)((cells[curCellOffset].right < 0) ? 0 :
                                         cells[curCellOffset].right - m_min_style + 1);

                        styleOffset = (int)style_id;
                        if (cells[curCellOffset].x == stylesArray[styleOffset].last_x)
                        {
                            cellOffset = stylesArray[styleOffset].start_cell + stylesArray[styleOffset].num_cells - 1;
                            unchecked
                            {
                                cells[cellOffset].area  -= cells[curCellOffset].area;
                                cells[cellOffset].cover -= cells[curCellOffset].cover;
                            }
                        }
                        else
                        {
                            cellOffset                      = stylesArray[styleOffset].start_cell + stylesArray[styleOffset].num_cells;
                            cells[cellOffset].x             = cells[curCellOffset].x;
                            cells[cellOffset].area          = -cells[curCellOffset].area;
                            cells[cellOffset].cover         = -cells[curCellOffset].cover;
                            stylesArray[styleOffset].last_x = cells[curCellOffset].x;
                            stylesArray[styleOffset].num_cells++;
                        }
                    }
                }
                if (m_ast.size() > 1)
                {
                    break;
                }
                ++m_scan_y;
            }
            ++m_scan_y;

            if (m_layer_order != layer_order_e.layer_unsorted)
            {
                VectorPOD_RangeAdaptor ra = new VectorPOD_RangeAdaptor(m_ast, 1, m_ast.size() - 1);
                if (m_layer_order == layer_order_e.layer_direct)
                {
                    QuickSort_range_adaptor_uint m_QSorter = new QuickSort_range_adaptor_uint();
                    m_QSorter.Sort(ra);
                    //quick_sort(ra, uint_greater);
                }
                else
                {
                    throw new System.NotImplementedException();
                    //QuickSort_range_adaptor_uint m_QSorter = new QuickSort_range_adaptor_uint();
                    //m_QSorter.Sort(ra);
                    //quick_sort(ra, uint_less);
                }
            }

            return(m_ast.size() - 1);
        }
Exemple #2
0
        //--------------------------------------------------------------------
        public bool sweep_scanline(IScanlineCache scanlineCache)
        {
            for (; ;)
            {
                if (m_scan_y > m_outline.max_y())
                {
                    return(false);
                }

                scanlineCache.ResetSpans();
                int       num_cells = (int)m_outline.scanline_num_cells(m_scan_y);
                cell_aa[] cells;
                int       Offset;
                m_outline.scanline_cells(m_scan_y, out cells, out Offset);
                int cover = 0;

                while (num_cells != 0)
                {
                    cell_aa cur_cell = cells[Offset];
                    int     x        = cur_cell.x;
                    int     area     = cur_cell.area;
                    int     alpha;

                    cover += cur_cell.cover;

                    //accumulate all cells with the same X
                    while (--num_cells != 0)
                    {
                        Offset++;
                        cur_cell = cells[Offset];
                        if (cur_cell.x != x)
                        {
                            break;
                        }

                        area  += cur_cell.area;
                        cover += cur_cell.cover;
                    }

                    if (area != 0)
                    {
                        alpha = calculate_alpha((cover << ((int)poly_subpixel_scale_e.poly_subpixel_shift + 1)) - area);
                        if (alpha != 0)
                        {
                            scanlineCache.add_cell(x, alpha);
                        }
                        x++;
                    }

                    if ((num_cells != 0) && (cur_cell.x > x))
                    {
                        alpha = calculate_alpha(cover << ((int)poly_subpixel_scale_e.poly_subpixel_shift + 1));
                        if (alpha != 0)
                        {
                            scanlineCache.add_span(x, (cur_cell.x - x), alpha);
                        }
                    }
                }

                if (scanlineCache.num_spans() != 0)
                {
                    break;
                }
                ++m_scan_y;
            }

            scanlineCache.finalize(m_scan_y);
            ++m_scan_y;
            return(true);
        }