Exemple #1
0
        //------------------------------------------------------------------------
        public void prepare()
        {
            if (m_num > 2)
            {
                int    i, k;
                int    r;
                int    s;
                double h, p, d, f, e;

                for (k = 0; k < m_num; k++)
                {
                    m_am[k] = 0.0;
                }

                int n1 = 3 * m_num;

                ArrayPOD <double> al = new ArrayPOD <double>(n1);

                for (k = 0; k < n1; k++)
                {
                    al[k] = 0.0;
                }

                r = m_num;
                s = m_num * 2;

                n1 = m_num - 1;
                d  = m_am[m_xOffset + 1] - m_am[m_xOffset + 0];
                e  = (m_am[m_yOffset + 1] - m_am[m_yOffset + 0]) / d;

                for (k = 1; k < n1; k++)
                {
                    h         = d;
                    d         = m_am[m_xOffset + k + 1] - m_am[m_xOffset + k];
                    f         = e;
                    e         = (m_am[m_yOffset + k + 1] - m_am[m_yOffset + k]) / d;
                    al[k]     = d / (d + h);
                    al[r + k] = 1.0 - al[k];
                    al[s + k] = 6.0 * (e - f) / (h + d);
                }

                for (k = 1; k < n1; k++)
                {
                    p         = 1.0 / (al[r + k] * al[k - 1] + 2.0);
                    al[k]    *= -p;
                    al[s + k] = (al[s + k] - al[r + k] * al[s + k - 1]) * p;
                }

                m_am[n1]     = 0.0;
                al[n1 - 1]   = al[s + n1 - 1];
                m_am[n1 - 1] = al[n1 - 1];

                for (k = n1 - 2, i = 0; i < m_num - 2; i++, k--)
                {
                    al[k]   = al[k] * al[k + 1] + al[s + k];
                    m_am[k] = al[k];
                }
            }
            m_last_idx = -1;
        }
 public ImageFilterLookUpTable()
 {
     m_weight_array = new ArrayPOD <int>(256);
     m_radius       = (0);
     m_diameter     = (0);
     m_start        = (0);
 }
 public ImageFilterLookUpTable(IImageFilterFunction filter, bool normalization)
 {
     m_weight_array = new ArrayPOD <int>(256);
     calculate(filter, normalization);
 }
Exemple #4
0
 public ArrayPOD(ArrayPOD <T> v)
 {
     m_array = (T[])v.m_array.Clone();
     m_size  = v.m_size;
 }
Exemple #5
0
        public void RenderCompound(rasterizer_compound_aa ras, IScanlineCache sl_aa, IScanlineCache sl_bin, IImageByte imageFormat, span_allocator alloc, IStyleHandler sh)
        {
#if false
            unsafe
            {
                if (ras.rewind_scanlines())
                {
                    int min_x = ras.min_x();
                    int len   = ras.max_x() - min_x + 2;
                    sl_aa.reset(min_x, ras.max_x());
                    sl_bin.reset(min_x, ras.max_x());

                    //typedef typename BaseRenderer::color_type color_type;
                    ArrayPOD <RGBA_Bytes> color_span = alloc.allocate((int)len * 2);
                    byte[] ManagedCoversArray        = sl_aa.GetCovers();
                    fixed(byte *pCovers = ManagedCoversArray)
                    {
                        fixed(RGBA_Bytes *pColorSpan = color_span.Array)
                        {
                            int mix_bufferOffset = len;
                            int num_spans;

                            int  num_styles;
                            int  style;
                            bool solid;

                            while ((num_styles = ras.sweep_styles()) > 0)
                            {
                                if (num_styles == 1)
                                {
                                    // Optimization for a single style. Happens often
                                    //-------------------------
                                    if (ras.sweep_scanline(sl_aa, 0))
                                    {
                                        style = ras.style(0);
                                        if (sh.is_solid(style))
                                        {
                                            // Just solid fill
                                            //-----------------------
                                            RenderSolidSingleScanLine(imageFormat, sl_aa, sh.color(style));
                                        }
                                        else
                                        {
                                            // Arbitrary span generator
                                            //-----------------------
                                            ScanlineSpan span_aa = sl_aa.Begin();
                                            num_spans = sl_aa.num_spans();
                                            for (; ;)
                                            {
                                                len = span_aa.len;
                                                sh.generate_span(pColorSpan,
                                                                 span_aa.x,
                                                                 sl_aa.y(),
                                                                 (int)len,
                                                                 style);

                                                imageFormat.blend_color_hspan(span_aa.x,
                                                                              sl_aa.y(),
                                                                              (int)span_aa.len,
                                                                              pColorSpan,
                                                                              &pCovers[span_aa.cover_index], 0);
                                                if (--num_spans == 0)
                                                {
                                                    break;
                                                }
                                                span_aa = sl_aa.GetNextScanlineSpan();
                                            }
                                        }
                                    }
                                }
                                else // there are multiple styles
                                {
                                    if (ras.sweep_scanline(sl_bin, -1))
                                    {
                                        // Clear the spans of the mix_buffer
                                        //--------------------
                                        ScanlineSpan span_bin = sl_bin.Begin();
                                        num_spans = sl_bin.num_spans();
                                        for (; ;)
                                        {
                                            agg_basics.MemClear((byte *)&pColorSpan[mix_bufferOffset + span_bin.x - min_x],
                                                                span_bin.len * sizeof(RGBA_Bytes));

                                            if (--num_spans == 0)
                                            {
                                                break;
                                            }
                                            span_bin = sl_bin.GetNextScanlineSpan();
                                        }

                                        for (int i = 0; i < num_styles; i++)
                                        {
                                            style = ras.style(i);
                                            solid = sh.is_solid(style);

                                            if (ras.sweep_scanline(sl_aa, (int)i))
                                            {
                                                //IColorType* colors;
                                                //IColorType* cspan;
                                                //typename ScanlineAA::cover_type* covers;
                                                ScanlineSpan span_aa = sl_aa.Begin();
                                                num_spans = sl_aa.num_spans();
                                                if (solid)
                                                {
                                                    // Just solid fill
                                                    //-----------------------
                                                    for (; ;)
                                                    {
                                                        RGBA_Bytes c = sh.color(style);
                                                        len = span_aa.len;
                                                        RGBA_Bytes *colors = &pColorSpan[mix_bufferOffset + span_aa.x - min_x];
                                                        byte *      covers = &pCovers[span_aa.cover_index];
                                                        do
                                                        {
                                                            if (*covers == cover_full)
                                                            {
                                                                *colors = c;
                                                            }
                                                            else
                                                            {
                                                                colors->add(c, *covers);
                                                            }
                                                            ++colors;
                                                            ++covers;
                                                        }while (--len != 0);
                                                        if (--num_spans == 0)
                                                        {
                                                            break;
                                                        }
                                                        span_aa = sl_aa.GetNextScanlineSpan();
                                                    }
                                                }
                                                else
                                                {
                                                    // Arbitrary span generator
                                                    //-----------------------
                                                    for (; ;)
                                                    {
                                                        len = span_aa.len;
                                                        RGBA_Bytes *colors = &pColorSpan[mix_bufferOffset + span_aa.x - min_x];
                                                        RGBA_Bytes *cspan  = pColorSpan;
                                                        sh.generate_span(cspan,
                                                                         span_aa.x,
                                                                         sl_aa.y(),
                                                                         (int)len,
                                                                         style);
                                                        byte *covers = &pCovers[span_aa.cover_index];
                                                        do
                                                        {
                                                            if (*covers == cover_full)
                                                            {
                                                                *colors = *cspan;
                                                            }
                                                            else
                                                            {
                                                                colors->add(*cspan, *covers);
                                                            }
                                                            ++cspan;
                                                            ++colors;
                                                            ++covers;
                                                        }while (--len != 0);
                                                        if (--num_spans == 0)
                                                        {
                                                            break;
                                                        }
                                                        span_aa = sl_aa.GetNextScanlineSpan();
                                                    }
                                                }
                                            }
                                        }

                                        // Emit the blended result as a color hspan
                                        //-------------------------
                                        span_bin  = sl_bin.Begin();
                                        num_spans = sl_bin.num_spans();
                                        for (; ;)
                                        {
                                            imageFormat.blend_color_hspan(span_bin.x,
                                                                          sl_bin.y(),
                                                                          (int)span_bin.len,
                                                                          &pColorSpan[mix_bufferOffset + span_bin.x - min_x],
                                                                          null,
                                                                          cover_full);
                                            if (--num_spans == 0)
                                            {
                                                break;
                                            }
                                            span_bin = sl_bin.GetNextScanlineSpan();
                                        }
                                    } // if(ras.sweep_scanline(sl_bin, -1))
                                }     // if(num_styles == 1) ... else
                            }         // while((num_styles = ras.sweep_styles()) > 0)
                        }
                    }
                } // if(ras.rewind_scanlines())
            }
#endif
        }
Exemple #6
0
 //--------------------------------------------------------------------
 public scanline_bin()
 {
     m_last_x     = (0x7FFFFFF0);
     m_spans      = new ArrayPOD <ScanlineSpan>(1000);
     m_span_index = 0;
 }