Menu
▾
▴
SF.net SVN: matplotlib: [4333] branches/transforms
|
From: <md...@us...> - 2007-11-16 15:54:04
|
Revision: 4333
http://matplotlib.svn.sourceforge.net/matplotlib/?rev=4333&view=rev
Author: mdboom
Date: 2007-11-16 07:53:57 -0800 (Fri, 16 Nov 2007)
Log Message:
-----------
Upgrade to Agg 2.4; Stop building Agg SWIG wrappers and remove small dependency on them.
Modified Paths:
--------------
branches/transforms/lib/matplotlib/mpl.py
branches/transforms/setup.py
branches/transforms/setupext.py
branches/transforms/src/_backend_agg.cpp
branches/transforms/src/_backend_agg.h
branches/transforms/src/_image.cpp
Added Paths:
-----------
branches/transforms/agg24/
branches/transforms/agg24/include/
branches/transforms/agg24/include/agg_alpha_mask_u8.h
branches/transforms/agg24/include/agg_arc.h
branches/transforms/agg24/include/agg_array.h
branches/transforms/agg24/include/agg_arrowhead.h
branches/transforms/agg24/include/agg_basics.h
branches/transforms/agg24/include/agg_bezier_arc.h
branches/transforms/agg24/include/agg_bitset_iterator.h
branches/transforms/agg24/include/agg_blur.h
branches/transforms/agg24/include/agg_bounding_rect.h
branches/transforms/agg24/include/agg_bspline.h
branches/transforms/agg24/include/agg_clip_liang_barsky.h
branches/transforms/agg24/include/agg_color_gray.h
branches/transforms/agg24/include/agg_color_rgba.h
branches/transforms/agg24/include/agg_config.h
branches/transforms/agg24/include/agg_conv_adaptor_vcgen.h
branches/transforms/agg24/include/agg_conv_adaptor_vpgen.h
branches/transforms/agg24/include/agg_conv_bspline.h
branches/transforms/agg24/include/agg_conv_clip_polygon.h
branches/transforms/agg24/include/agg_conv_clip_polyline.h
branches/transforms/agg24/include/agg_conv_close_polygon.h
branches/transforms/agg24/include/agg_conv_concat.h
branches/transforms/agg24/include/agg_conv_contour.h
branches/transforms/agg24/include/agg_conv_curve.h
branches/transforms/agg24/include/agg_conv_dash.h
branches/transforms/agg24/include/agg_conv_gpc.h
branches/transforms/agg24/include/agg_conv_marker.h
branches/transforms/agg24/include/agg_conv_marker_adaptor.h
branches/transforms/agg24/include/agg_conv_segmentator.h
branches/transforms/agg24/include/agg_conv_shorten_path.h
branches/transforms/agg24/include/agg_conv_smooth_poly1.h
branches/transforms/agg24/include/agg_conv_stroke.h
branches/transforms/agg24/include/agg_conv_transform.h
branches/transforms/agg24/include/agg_conv_unclose_polygon.h
branches/transforms/agg24/include/agg_curves.h
branches/transforms/agg24/include/agg_dda_line.h
branches/transforms/agg24/include/agg_ellipse.h
branches/transforms/agg24/include/agg_ellipse_bresenham.h
branches/transforms/agg24/include/agg_embedded_raster_fonts.h
branches/transforms/agg24/include/agg_font_cache_manager.h
branches/transforms/agg24/include/agg_gamma_functions.h
branches/transforms/agg24/include/agg_gamma_lut.h
branches/transforms/agg24/include/agg_glyph_raster_bin.h
branches/transforms/agg24/include/agg_gradient_lut.h
branches/transforms/agg24/include/agg_gsv_text.h
branches/transforms/agg24/include/agg_image_accessors.h
branches/transforms/agg24/include/agg_image_filters.h
branches/transforms/agg24/include/agg_line_aa_basics.h
branches/transforms/agg24/include/agg_math.h
branches/transforms/agg24/include/agg_math_stroke.h
branches/transforms/agg24/include/agg_path_length.h
branches/transforms/agg24/include/agg_path_storage.h
branches/transforms/agg24/include/agg_path_storage_integer.h
branches/transforms/agg24/include/agg_pattern_filters_rgba.h
branches/transforms/agg24/include/agg_pixfmt_amask_adaptor.h
branches/transforms/agg24/include/agg_pixfmt_gray.h
branches/transforms/agg24/include/agg_pixfmt_rgb.h
branches/transforms/agg24/include/agg_pixfmt_rgb_packed.h
branches/transforms/agg24/include/agg_pixfmt_rgba.h
branches/transforms/agg24/include/agg_pixfmt_transposer.h
branches/transforms/agg24/include/agg_rasterizer_cells_aa.h
branches/transforms/agg24/include/agg_rasterizer_compound_aa.h
branches/transforms/agg24/include/agg_rasterizer_outline.h
branches/transforms/agg24/include/agg_rasterizer_outline_aa.h
branches/transforms/agg24/include/agg_rasterizer_scanline_aa.h
branches/transforms/agg24/include/agg_rasterizer_sl_clip.h
branches/transforms/agg24/include/agg_renderer_base.h
branches/transforms/agg24/include/agg_renderer_markers.h
branches/transforms/agg24/include/agg_renderer_mclip.h
branches/transforms/agg24/include/agg_renderer_outline_aa.h
branches/transforms/agg24/include/agg_renderer_outline_image.h
branches/transforms/agg24/include/agg_renderer_primitives.h
branches/transforms/agg24/include/agg_renderer_raster_text.h
branches/transforms/agg24/include/agg_renderer_scanline.h
branches/transforms/agg24/include/agg_rendering_buffer.h
branches/transforms/agg24/include/agg_rendering_buffer_dynarow.h
branches/transforms/agg24/include/agg_rounded_rect.h
branches/transforms/agg24/include/agg_scanline_bin.h
branches/transforms/agg24/include/agg_scanline_boolean_algebra.h
branches/transforms/agg24/include/agg_scanline_p.h
branches/transforms/agg24/include/agg_scanline_storage_aa.h
branches/transforms/agg24/include/agg_scanline_storage_bin.h
branches/transforms/agg24/include/agg_scanline_u.h
branches/transforms/agg24/include/agg_shorten_path.h
branches/transforms/agg24/include/agg_simul_eq.h
branches/transforms/agg24/include/agg_span_allocator.h
branches/transforms/agg24/include/agg_span_converter.h
branches/transforms/agg24/include/agg_span_gouraud.h
branches/transforms/agg24/include/agg_span_gouraud_gray.h
branches/transforms/agg24/include/agg_span_gouraud_rgba.h
branches/transforms/agg24/include/agg_span_gradient.h
branches/transforms/agg24/include/agg_span_gradient_alpha.h
branches/transforms/agg24/include/agg_span_image_filter.h
branches/transforms/agg24/include/agg_span_image_filter_gray.h
branches/transforms/agg24/include/agg_span_image_filter_rgb.h
branches/transforms/agg24/include/agg_span_image_filter_rgba.h
branches/transforms/agg24/include/agg_span_interpolator_adaptor.h
branches/transforms/agg24/include/agg_span_interpolator_linear.h
branches/transforms/agg24/include/agg_span_interpolator_persp.h
branches/transforms/agg24/include/agg_span_interpolator_trans.h
branches/transforms/agg24/include/agg_span_pattern_gray.h
branches/transforms/agg24/include/agg_span_pattern_rgb.h
branches/transforms/agg24/include/agg_span_pattern_rgba.h
branches/transforms/agg24/include/agg_span_solid.h
branches/transforms/agg24/include/agg_span_subdiv_adaptor.h
branches/transforms/agg24/include/agg_trans_affine.h
branches/transforms/agg24/include/agg_trans_bilinear.h
branches/transforms/agg24/include/agg_trans_double_path.h
branches/transforms/agg24/include/agg_trans_perspective.h
branches/transforms/agg24/include/agg_trans_single_path.h
branches/transforms/agg24/include/agg_trans_viewport.h
branches/transforms/agg24/include/agg_trans_warp_magnifier.h
branches/transforms/agg24/include/agg_vcgen_bspline.h
branches/transforms/agg24/include/agg_vcgen_contour.h
branches/transforms/agg24/include/agg_vcgen_dash.h
branches/transforms/agg24/include/agg_vcgen_markers_term.h
branches/transforms/agg24/include/agg_vcgen_smooth_poly1.h
branches/transforms/agg24/include/agg_vcgen_stroke.h
branches/transforms/agg24/include/agg_vcgen_vertex_sequence.h
branches/transforms/agg24/include/agg_vertex_sequence.h
branches/transforms/agg24/include/agg_vpgen_clip_polygon.h
branches/transforms/agg24/include/agg_vpgen_clip_polyline.h
branches/transforms/agg24/include/agg_vpgen_segmentator.h
branches/transforms/agg24/include/ctrl/
branches/transforms/agg24/include/ctrl/agg_bezier_ctrl.h
branches/transforms/agg24/include/ctrl/agg_cbox_ctrl.h
branches/transforms/agg24/include/ctrl/agg_ctrl.h
branches/transforms/agg24/include/ctrl/agg_gamma_ctrl.h
branches/transforms/agg24/include/ctrl/agg_gamma_spline.h
branches/transforms/agg24/include/ctrl/agg_polygon_ctrl.h
branches/transforms/agg24/include/ctrl/agg_rbox_ctrl.h
branches/transforms/agg24/include/ctrl/agg_scale_ctrl.h
branches/transforms/agg24/include/ctrl/agg_slider_ctrl.h
branches/transforms/agg24/include/ctrl/agg_spline_ctrl.h
branches/transforms/agg24/include/platform/
branches/transforms/agg24/include/platform/agg_platform_support.h
branches/transforms/agg24/include/platform/mac/
branches/transforms/agg24/include/platform/mac/agg_mac_pmap.h
branches/transforms/agg24/include/platform/win32/
branches/transforms/agg24/include/platform/win32/agg_win32_bmp.h
branches/transforms/agg24/include/util/
branches/transforms/agg24/include/util/agg_color_conv.h
branches/transforms/agg24/include/util/agg_color_conv_rgb16.h
branches/transforms/agg24/include/util/agg_color_conv_rgb8.h
branches/transforms/agg24/src/
branches/transforms/agg24/src/ChangeLog
branches/transforms/agg24/src/agg_arc.cpp
branches/transforms/agg24/src/agg_arrowhead.cpp
branches/transforms/agg24/src/agg_bezier_arc.cpp
branches/transforms/agg24/src/agg_bspline.cpp
branches/transforms/agg24/src/agg_curves.cpp
branches/transforms/agg24/src/agg_embedded_raster_fonts.cpp
branches/transforms/agg24/src/agg_gsv_text.cpp
branches/transforms/agg24/src/agg_image_filters.cpp
branches/transforms/agg24/src/agg_line_aa_basics.cpp
branches/transforms/agg24/src/agg_line_profile_aa.cpp
branches/transforms/agg24/src/agg_rounded_rect.cpp
branches/transforms/agg24/src/agg_sqrt_tables.cpp
branches/transforms/agg24/src/agg_trans_affine.cpp
branches/transforms/agg24/src/agg_trans_double_path.cpp
branches/transforms/agg24/src/agg_trans_single_path.cpp
branches/transforms/agg24/src/agg_trans_warp_magnifier.cpp
branches/transforms/agg24/src/agg_vcgen_bspline.cpp
branches/transforms/agg24/src/agg_vcgen_contour.cpp
branches/transforms/agg24/src/agg_vcgen_dash.cpp
branches/transforms/agg24/src/agg_vcgen_markers_term.cpp
branches/transforms/agg24/src/agg_vcgen_smooth_poly1.cpp
branches/transforms/agg24/src/agg_vcgen_stroke.cpp
branches/transforms/agg24/src/agg_vpgen_clip_polygon.cpp
branches/transforms/agg24/src/agg_vpgen_clip_polyline.cpp
branches/transforms/agg24/src/agg_vpgen_segmentator.cpp
branches/transforms/agg24/src/authors
branches/transforms/agg24/src/copying
branches/transforms/agg24/src/ctrl/
branches/transforms/agg24/src/ctrl/agg_bezier_ctrl.cpp
branches/transforms/agg24/src/ctrl/agg_cbox_ctrl.cpp
branches/transforms/agg24/src/ctrl/agg_gamma_ctrl.cpp
branches/transforms/agg24/src/ctrl/agg_gamma_spline.cpp
branches/transforms/agg24/src/ctrl/agg_polygon_ctrl.cpp
branches/transforms/agg24/src/ctrl/agg_rbox_ctrl.cpp
branches/transforms/agg24/src/ctrl/agg_scale_ctrl.cpp
branches/transforms/agg24/src/ctrl/agg_slider_ctrl.cpp
branches/transforms/agg24/src/ctrl/agg_spline_ctrl.cpp
branches/transforms/agg24/src/platform/
branches/transforms/agg24/src/platform/AmigaOS/
branches/transforms/agg24/src/platform/AmigaOS/agg_platform_support.cpp
branches/transforms/agg24/src/platform/BeOS/
branches/transforms/agg24/src/platform/BeOS/agg_platform_support.cpp
branches/transforms/agg24/src/platform/X11/
branches/transforms/agg24/src/platform/X11/agg_platform_support.cpp
branches/transforms/agg24/src/platform/mac/
branches/transforms/agg24/src/platform/mac/agg_mac_pmap.cpp
branches/transforms/agg24/src/platform/mac/agg_platform_support.cpp
branches/transforms/agg24/src/platform/sdl/
branches/transforms/agg24/src/platform/sdl/agg_platform_support.cpp
branches/transforms/agg24/src/platform/win32/
branches/transforms/agg24/src/platform/win32/agg_platform_support.cpp
branches/transforms/agg24/src/platform/win32/agg_win32_bmp.cpp
Removed Paths:
-------------
branches/transforms/agg23/
Added: branches/transforms/agg24/include/agg_alpha_mask_u8.h
===================================================================
--- branches/transforms/agg24/include/agg_alpha_mask_u8.h (rev 0)
+++ branches/transforms/agg24/include/agg_alpha_mask_u8.h 2007-11-16 15:53:57 UTC (rev 4333)
@@ -0,0 +1,499 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mc...@an...
+// mcs...@ya...
+// http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// scanline_u8 class
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_ALPHA_MASK_U8_INCLUDED
+#define AGG_ALPHA_MASK_U8_INCLUDED
+
+#include <string.h>
+#include "agg_basics.h"
+#include "agg_rendering_buffer.h"
+
+namespace agg
+{
+ //===================================================one_component_mask_u8
+ struct one_component_mask_u8
+ {
+ static unsigned calculate(const int8u* p) { return *p; }
+ };
+
+
+ //=====================================================rgb_to_gray_mask_u8
+ template<unsigned R, unsigned G, unsigned B>
+ struct rgb_to_gray_mask_u8
+ {
+ static unsigned calculate(const int8u* p)
+ {
+ return (p[R]*77 + p[G]*150 + p[B]*29) >> 8;
+ }
+ };
+
+ //==========================================================alpha_mask_u8
+ template<unsigned Step=1, unsigned Offset=0, class MaskF=one_component_mask_u8>
+ class alpha_mask_u8
+ {
+ public:
+ typedef int8u cover_type;
+ typedef alpha_mask_u8<Step, Offset, MaskF> self_type;
+ enum cover_scale_e
+ {
+ cover_shift = 8,
+ cover_none = 0,
+ cover_full = 255
+ };
+
+ alpha_mask_u8() : m_rbuf(0) {}
+ explicit alpha_mask_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
+
+ void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
+
+ MaskF& mask_function() { return m_mask_function; }
+ const MaskF& mask_function() const { return m_mask_function; }
+
+
+ //--------------------------------------------------------------------
+ cover_type pixel(int x, int y) const
+ {
+ if(x >= 0 && y >= 0 &&
+ x < (int)m_rbuf->width() &&
+ y < (int)m_rbuf->height())
+ {
+ return (cover_type)m_mask_function.calculate(
+ m_rbuf->row_ptr(y) + x * Step + Offset);
+ }
+ return 0;
+ }
+
+ //--------------------------------------------------------------------
+ cover_type combine_pixel(int x, int y, cover_type val) const
+ {
+ if(x >= 0 && y >= 0 &&
+ x < (int)m_rbuf->width() &&
+ y < (int)m_rbuf->height())
+ {
+ return (cover_type)((cover_full + val *
+ m_mask_function.calculate(
+ m_rbuf->row_ptr(y) + x * Step + Offset)) >>
+ cover_shift);
+ }
+ return 0;
+ }
+
+
+ //--------------------------------------------------------------------
+ void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
+ {
+ int xmax = m_rbuf->width() - 1;
+ int ymax = m_rbuf->height() - 1;
+
+ int count = num_pix;
+ cover_type* covers = dst;
+
+ if(y < 0 || y > ymax)
+ {
+ memset(dst, 0, num_pix * sizeof(cover_type));
+ return;
+ }
+
+ if(x < 0)
+ {
+ count += x;
+ if(count <= 0)
+ {
+ memset(dst, 0, num_pix * sizeof(cover_type));
+ return;
+ }
+ memset(covers, 0, -x * sizeof(cover_type));
+ covers -= x;
+ x = 0;
+ }
+
+ if(x + count > xmax)
+ {
+ int rest = x + count - xmax - 1;
+ count -= rest;
+ if(count <= 0)
+ {
+ memset(dst, 0, num_pix * sizeof(cover_type));
+ return;
+ }
+ memset(covers + count, 0, rest * sizeof(cover_type));
+ }
+
+ const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+ do
+ {
+ *covers++ = (cover_type)m_mask_function.calculate(mask);
+ mask += Step;
+ }
+ while(--count);
+ }
+
+
+ //--------------------------------------------------------------------
+ void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
+ {
+ int xmax = m_rbuf->width() - 1;
+ int ymax = m_rbuf->height() - 1;
+
+ int count = num_pix;
+ cover_type* covers = dst;
+
+ if(y < 0 || y > ymax)
+ {
+ memset(dst, 0, num_pix * sizeof(cover_type));
+ return;
+ }
+
+ if(x < 0)
+ {
+ count += x;
+ if(count <= 0)
+ {
+ memset(dst, 0, num_pix * sizeof(cover_type));
+ return;
+ }
+ memset(covers, 0, -x * sizeof(cover_type));
+ covers -= x;
+ x = 0;
+ }
+
+ if(x + count > xmax)
+ {
+ int rest = x + count - xmax - 1;
+ count -= rest;
+ if(count <= 0)
+ {
+ memset(dst, 0, num_pix * sizeof(cover_type));
+ return;
+ }
+ memset(covers + count, 0, rest * sizeof(cover_type));
+ }
+
+ const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+ do
+ {
+ *covers = (cover_type)((cover_full + (*covers) *
+ m_mask_function.calculate(mask)) >>
+ cover_shift);
+ ++covers;
+ mask += Step;
+ }
+ while(--count);
+ }
+
+ //--------------------------------------------------------------------
+ void fill_vspan(int x, int y, cover_type* dst, int num_pix) const
+ {
+ int xmax = m_rbuf->width() - 1;
+ int ymax = m_rbuf->height() - 1;
+
+ int count = num_pix;
+ cover_type* covers = dst;
+
+ if(x < 0 || x > xmax)
+ {
+ memset(dst, 0, num_pix * sizeof(cover_type));
+ return;
+ }
+
+ if(y < 0)
+ {
+ count += y;
+ if(count <= 0)
+ {
+ memset(dst, 0, num_pix * sizeof(cover_type));
+ return;
+ }
+ memset(covers, 0, -y * sizeof(cover_type));
+ covers -= y;
+ y = 0;
+ }
+
+ if(y + count > ymax)
+ {
+ int rest = y + count - ymax - 1;
+ count -= rest;
+ if(count <= 0)
+ {
+ memset(dst, 0, num_pix * sizeof(cover_type));
+ return;
+ }
+ memset(covers + count, 0, rest * sizeof(cover_type));
+ }
+
+ const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+ do
+ {
+ *covers++ = (cover_type)m_mask_function.calculate(mask);
+ mask += m_rbuf->stride();
+ }
+ while(--count);
+ }
+
+ //--------------------------------------------------------------------
+ void combine_vspan(int x, int y, cover_type* dst, int num_pix) const
+ {
+ int xmax = m_rbuf->width() - 1;
+ int ymax = m_rbuf->height() - 1;
+
+ int count = num_pix;
+ cover_type* covers = dst;
+
+ if(x < 0 || x > xmax)
+ {
+ memset(dst, 0, num_pix * sizeof(cover_type));
+ return;
+ }
+
+ if(y < 0)
+ {
+ count += y;
+ if(count <= 0)
+ {
+ memset(dst, 0, num_pix * sizeof(cover_type));
+ return;
+ }
+ memset(covers, 0, -y * sizeof(cover_type));
+ covers -= y;
+ y = 0;
+ }
+
+ if(y + count > ymax)
+ {
+ int rest = y + count - ymax - 1;
+ count -= rest;
+ if(count <= 0)
+ {
+ memset(dst, 0, num_pix * sizeof(cover_type));
+ return;
+ }
+ memset(covers + count, 0, rest * sizeof(cover_type));
+ }
+
+ const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+ do
+ {
+ *covers = (cover_type)((cover_full + (*covers) *
+ m_mask_function.calculate(mask)) >>
+ cover_shift);
+ ++covers;
+ mask += m_rbuf->stride();
+ }
+ while(--count);
+ }
+
+
+ private:
+ alpha_mask_u8(const self_type&);
+ const self_type& operator = (const self_type&);
+
+ rendering_buffer* m_rbuf;
+ MaskF m_mask_function;
+ };
+
+
+ typedef alpha_mask_u8<1, 0> alpha_mask_gray8; //----alpha_mask_gray8
+
+ typedef alpha_mask_u8<3, 0> alpha_mask_rgb24r; //----alpha_mask_rgb24r
+ typedef alpha_mask_u8<3, 1> alpha_mask_rgb24g; //----alpha_mask_rgb24g
+ typedef alpha_mask_u8<3, 2> alpha_mask_rgb24b; //----alpha_mask_rgb24b
+
+ typedef alpha_mask_u8<3, 2> alpha_mask_bgr24r; //----alpha_mask_bgr24r
+ typedef alpha_mask_u8<3, 1> alpha_mask_bgr24g; //----alpha_mask_bgr24g
+ typedef alpha_mask_u8<3, 0> alpha_mask_bgr24b; //----alpha_mask_bgr24b
+
+ typedef alpha_mask_u8<4, 0> alpha_mask_rgba32r; //----alpha_mask_rgba32r
+ typedef alpha_mask_u8<4, 1> alpha_mask_rgba32g; //----alpha_mask_rgba32g
+ typedef alpha_mask_u8<4, 2> alpha_mask_rgba32b; //----alpha_mask_rgba32b
+ typedef alpha_mask_u8<4, 3> alpha_mask_rgba32a; //----alpha_mask_rgba32a
+
+ typedef alpha_mask_u8<4, 1> alpha_mask_argb32r; //----alpha_mask_argb32r
+ typedef alpha_mask_u8<4, 2> alpha_mask_argb32g; //----alpha_mask_argb32g
+ typedef alpha_mask_u8<4, 3> alpha_mask_argb32b; //----alpha_mask_argb32b
+ typedef alpha_mask_u8<4, 0> alpha_mask_argb32a; //----alpha_mask_argb32a
+
+ typedef alpha_mask_u8<4, 2> alpha_mask_bgra32r; //----alpha_mask_bgra32r
+ typedef alpha_mask_u8<4, 1> alpha_mask_bgra32g; //----alpha_mask_bgra32g
+ typedef alpha_mask_u8<4, 0> alpha_mask_bgra32b; //----alpha_mask_bgra32b
+ typedef alpha_mask_u8<4, 3> alpha_mask_bgra32a; //----alpha_mask_bgra32a
+
+ typedef alpha_mask_u8<4, 3> alpha_mask_abgr32r; //----alpha_mask_abgr32r
+ typedef alpha_mask_u8<4, 2> alpha_mask_abgr32g; //----alpha_mask_abgr32g
+ typedef alpha_mask_u8<4, 1> alpha_mask_abgr32b; //----alpha_mask_abgr32b
+ typedef alpha_mask_u8<4, 0> alpha_mask_abgr32a; //----alpha_mask_abgr32a
+
+ typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_rgb24gray; //----alpha_mask_rgb24gray
+ typedef alpha_mask_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_bgr24gray; //----alpha_mask_bgr24gray
+ typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_rgba32gray; //----alpha_mask_rgba32gray
+ typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2> > alpha_mask_argb32gray; //----alpha_mask_argb32gray
+ typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_bgra32gray; //----alpha_mask_bgra32gray
+ typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0> > alpha_mask_abgr32gray; //----alpha_mask_abgr32gray
+
+
+
+ //==========================================================amask_no_clip_u8
+ template<unsigned Step=1, unsigned Offset=0, class MaskF=one_component_mask_u8>
+ class amask_no_clip_u8
+ {
+ public:
+ typedef int8u cover_type;
+ typedef amask_no_clip_u8<Step, Offset, MaskF> self_type;
+ enum cover_scale_e
+ {
+ cover_shift = 8,
+ cover_none = 0,
+ cover_full = 255
+ };
+
+ amask_no_clip_u8() : m_rbuf(0) {}
+ explicit amask_no_clip_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
+
+ void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
+
+ MaskF& mask_function() { return m_mask_function; }
+ const MaskF& mask_function() const { return m_mask_function; }
+
+
+ //--------------------------------------------------------------------
+ cover_type pixel(int x, int y) const
+ {
+ return (cover_type)m_mask_function.calculate(
+ m_rbuf->row_ptr(y) + x * Step + Offset);
+ }
+
+
+ //--------------------------------------------------------------------
+ cover_type combine_pixel(int x, int y, cover_type val) const
+ {
+ return (cover_type)((cover_full + val *
+ m_mask_function.calculate(
+ m_rbuf->row_ptr(y) + x * Step + Offset)) >>
+ cover_shift);
+ }
+
+
+ //--------------------------------------------------------------------
+ void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
+ {
+ const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+ do
+ {
+ *dst++ = (cover_type)m_mask_function.calculate(mask);
+ mask += Step;
+ }
+ while(--num_pix);
+ }
+
+
+
+ //--------------------------------------------------------------------
+ void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
+ {
+ const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+ do
+ {
+ *dst = (cover_type)((cover_full + (*dst) *
+ m_mask_function.calculate(mask)) >>
+ cover_shift);
+ ++dst;
+ mask += Step;
+ }
+ while(--num_pix);
+ }
+
+
+ //--------------------------------------------------------------------
+ void fill_vspan(int x, int y, cover_type* dst, int num_pix) const
+ {
+ const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+ do
+ {
+ *dst++ = (cover_type)m_mask_function.calculate(mask);
+ mask += m_rbuf->stride();
+ }
+ while(--num_pix);
+ }
+
+
+ //--------------------------------------------------------------------
+ void combine_vspan(int x, int y, cover_type* dst, int num_pix) const
+ {
+ const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
+ do
+ {
+ *dst = (cover_type)((cover_full + (*dst) *
+ m_mask_function.calculate(mask)) >>
+ cover_shift);
+ ++dst;
+ mask += m_rbuf->stride();
+ }
+ while(--num_pix);
+ }
+
+ private:
+ amask_no_clip_u8(const self_type&);
+ const self_type& operator = (const self_type&);
+
+ rendering_buffer* m_rbuf;
+ MaskF m_mask_function;
+ };
+
+
+ typedef amask_no_clip_u8<1, 0> amask_no_clip_gray8; //----amask_no_clip_gray8
+
+ typedef amask_no_clip_u8<3, 0> amask_no_clip_rgb24r; //----amask_no_clip_rgb24r
+ typedef amask_no_clip_u8<3, 1> amask_no_clip_rgb24g; //----amask_no_clip_rgb24g
+ typedef amask_no_clip_u8<3, 2> amask_no_clip_rgb24b; //----amask_no_clip_rgb24b
+
+ typedef amask_no_clip_u8<3, 2> amask_no_clip_bgr24r; //----amask_no_clip_bgr24r
+ typedef amask_no_clip_u8<3, 1> amask_no_clip_bgr24g; //----amask_no_clip_bgr24g
+ typedef amask_no_clip_u8<3, 0> amask_no_clip_bgr24b; //----amask_no_clip_bgr24b
+
+ typedef amask_no_clip_u8<4, 0> amask_no_clip_rgba32r; //----amask_no_clip_rgba32r
+ typedef amask_no_clip_u8<4, 1> amask_no_clip_rgba32g; //----amask_no_clip_rgba32g
+ typedef amask_no_clip_u8<4, 2> amask_no_clip_rgba32b; //----amask_no_clip_rgba32b
+ typedef amask_no_clip_u8<4, 3> amask_no_clip_rgba32a; //----amask_no_clip_rgba32a
+
+ typedef amask_no_clip_u8<4, 1> amask_no_clip_argb32r; //----amask_no_clip_argb32r
+ typedef amask_no_clip_u8<4, 2> amask_no_clip_argb32g; //----amask_no_clip_argb32g
+ typedef amask_no_clip_u8<4, 3> amask_no_clip_argb32b; //----amask_no_clip_argb32b
+ typedef amask_no_clip_u8<4, 0> amask_no_clip_argb32a; //----amask_no_clip_argb32a
+
+ typedef amask_no_clip_u8<4, 2> amask_no_clip_bgra32r; //----amask_no_clip_bgra32r
+ typedef amask_no_clip_u8<4, 1> amask_no_clip_bgra32g; //----amask_no_clip_bgra32g
+ typedef amask_no_clip_u8<4, 0> amask_no_clip_bgra32b; //----amask_no_clip_bgra32b
+ typedef amask_no_clip_u8<4, 3> amask_no_clip_bgra32a; //----amask_no_clip_bgra32a
+
+ typedef amask_no_clip_u8<4, 3> amask_no_clip_abgr32r; //----amask_no_clip_abgr32r
+ typedef amask_no_clip_u8<4, 2> amask_no_clip_abgr32g; //----amask_no_clip_abgr32g
+ typedef amask_no_clip_u8<4, 1> amask_no_clip_abgr32b; //----amask_no_clip_abgr32b
+ typedef amask_no_clip_u8<4, 0> amask_no_clip_abgr32a; //----amask_no_clip_abgr32a
+
+ typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_rgb24gray; //----amask_no_clip_rgb24gray
+ typedef amask_no_clip_u8<3, 0, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_bgr24gray; //----amask_no_clip_bgr24gray
+ typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_rgba32gray; //----amask_no_clip_rgba32gray
+ typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<0, 1, 2> > amask_no_clip_argb32gray; //----amask_no_clip_argb32gray
+ typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_bgra32gray; //----amask_no_clip_bgra32gray
+ typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0> > amask_no_clip_abgr32gray; //----amask_no_clip_abgr32gray
+
+
+}
+
+
+
+#endif
Added: branches/transforms/agg24/include/agg_arc.h
===================================================================
--- branches/transforms/agg24/include/agg_arc.h (rev 0)
+++ branches/transforms/agg24/include/agg_arc.h 2007-11-16 15:53:57 UTC (rev 4333)
@@ -0,0 +1,74 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mc...@an...
+// mcs...@ya...
+// http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Arc vertex generator
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_ARC_INCLUDED
+#define AGG_ARC_INCLUDED
+
+#include <math.h>
+#include "agg_basics.h"
+
+namespace agg
+{
+
+ //=====================================================================arc
+ //
+ // See Implementation agg_arc.cpp
+ //
+ class arc
+ {
+ public:
+ arc() : m_scale(1.0), m_initialized(false) {}
+ arc(double x, double y,
+ double rx, double ry,
+ double a1, double a2,
+ bool ccw=true);
+
+ void init(double x, double y,
+ double rx, double ry,
+ double a1, double a2,
+ bool ccw=true);
+
+ void approximation_scale(double s);
+ double approximation_scale() const { return m_scale; }
+
+ void rewind(unsigned);
+ unsigned vertex(double* x, double* y);
+
+ private:
+ void normalize(double a1, double a2, bool ccw);
+
+ double m_x;
+ double m_y;
+ double m_rx;
+ double m_ry;
+ double m_angle;
+ double m_start;
+ double m_end;
+ double m_scale;
+ double m_da;
+ bool m_ccw;
+ bool m_initialized;
+ unsigned m_path_cmd;
+ };
+
+
+}
+
+
+#endif
Added: branches/transforms/agg24/include/agg_array.h
===================================================================
--- branches/transforms/agg24/include/agg_array.h (rev 0)
+++ branches/transforms/agg24/include/agg_array.h 2007-11-16 15:53:57 UTC (rev 4333)
@@ -0,0 +1,1119 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mc...@an...
+// mcs...@ya...
+// http://www.antigrain.com
+//----------------------------------------------------------------------------
+#ifndef AGG_ARRAY_INCLUDED
+#define AGG_ARRAY_INCLUDED
+
+#include <stddef.h>
+#include <string.h>
+#include "agg_basics.h"
+
+namespace agg
+{
+
+ //-------------------------------------------------------pod_array_adaptor
+ template<class T> class pod_array_adaptor
+ {
+ public:
+ typedef T value_type;
+ pod_array_adaptor(T* array, unsigned size) :
+ m_array(array), m_size(size) {}
+
+ unsigned size() const { return m_size; }
+ const T& operator [] (unsigned i) const { return m_array[i]; }
+ T& operator [] (unsigned i) { return m_array[i]; }
+ const T& at(unsigned i) const { return m_array[i]; }
+ T& at(unsigned i) { return m_array[i]; }
+ T value_at(unsigned i) const { return m_array[i]; }
+
+ private:
+ T* m_array;
+ unsigned m_size;
+ };
+
+
+ //---------------------------------------------------------pod_auto_array
+ template<class T, unsigned Size> class pod_auto_array
+ {
+ public:
+ typedef T value_type;
+ typedef pod_auto_array<T, Size> self_type;
+
+ pod_auto_array() {}
+ explicit pod_auto_array(const T* c)
+ {
+ memcpy(m_array, c, sizeof(T) * Size);
+ }
+
+ const self_type& operator = (const T* c)
+ {
+ memcpy(m_array, c, sizeof(T) * Size);
+ return *this;
+ }
+
+ static unsigned size() { return Size; }
+ const T& operator [] (unsigned i) const { return m_array[i]; }
+ T& operator [] (unsigned i) { return m_array[i]; }
+ const T& at(unsigned i) const { return m_array[i]; }
+ T& at(unsigned i) { return m_array[i]; }
+ T value_at(unsigned i) const { return m_array[i]; }
+
+ private:
+ T m_array[Size];
+ };
+
+
+ //--------------------------------------------------------pod_auto_vector
+ template<class T, unsigned Size> class pod_auto_vector
+ {
+ public:
+ typedef T value_type;
+ typedef pod_auto_vector<T, Size> self_type;
+
+ pod_auto_vector() : m_size(0) {}
+
+ void remove_all() { m_size = 0; }
+ void clear() { m_size = 0; }
+ void add(const T& v) { m_array[m_size++] = v; }
+ void push_back(const T& v) { m_array[m_size++] = v; }
+ void inc_size(unsigned size) { m_size += size; }
+
+ unsigned size() const { return m_size; }
+ const T& operator [] (unsigned i) const { return m_array[i]; }
+ T& operator [] (unsigned i) { return m_array[i]; }
+ const T& at(unsigned i) const { return m_array[i]; }
+ T& at(unsigned i) { return m_array[i]; }
+ T value_at(unsigned i) const { return m_array[i]; }
+
+ private:
+ T m_array[Size];
+ unsigned m_size;
+ };
+
+
+ //---------------------------------------------------------------pod_array
+ template<class T> class pod_array
+ {
+ public:
+ typedef T value_type;
+ typedef pod_array<T> self_type;
+
+ ~pod_array() { pod_allocator<T>::deallocate(m_array, m_size); }
+ pod_array() : m_array(0), m_size(0) {}
+
+ pod_array(unsigned size) :
+ m_array(pod_allocator<T>::allocate(size)),
+ m_size(size)
+ {}
+
+ pod_array(const self_type& v) :
+ m_array(pod_allocator<T>::allocate(v.m_size)),
+ m_size(v.m_size)
+ {
+ memcpy(m_array, v.m_array, sizeof(T) * m_size);
+ }
+
+ void resize(unsigned size)
+ {
+ if(size != m_size)
+ {
+ pod_allocator<T>::deallocate(m_array, m_size);
+ m_array = pod_allocator<T>::allocate(m_size = size);
+ }
+ }
+ const self_type& operator = (const self_type& v)
+ {
+ resize(v.size());
+ memcpy(m_array, v.m_array, sizeof(T) * m_size);
+ return *this;
+ }
+
+ unsigned size() const { return m_size; }
+ const T& operator [] (unsigned i) const { return m_array[i]; }
+ T& operator [] (unsigned i) { return m_array[i]; }
+ const T& at(unsigned i) const { return m_array[i]; }
+ T& at(unsigned i) { return m_array[i]; }
+ T value_at(unsigned i) const { return m_array[i]; }
+
+ const T* data() const { return m_array; }
+ T* data() { return m_array; }
+ private:
+ T* m_array;
+ unsigned m_size;
+ };
+
+
+
+ //--------------------------------------------------------------pod_vector
+ // A simple class template to store Plain Old Data, a vector
+ // of a fixed size. The data is continous in memory
+ //------------------------------------------------------------------------
+ template<class T> class pod_vector
+ {
+ public:
+ typedef T value_type;
+
+ ~pod_vector() { pod_allocator<T>::deallocate(m_array, m_capacity); }
+ pod_vector() : m_size(0), m_capacity(0), m_array(0) {}
+ pod_vector(unsigned cap, unsigned extra_tail=0);
+
+ // Copying
+ pod_vector(const pod_vector<T>&);
+ const pod_vector<T>& operator = (const pod_vector<T>&);
+
+ // Set new capacity. All data is lost, size is set to zero.
+ void capacity(unsigned cap, unsigned extra_tail=0);
+ unsigned capacity() const { return m_capacity; }
+
+ // Allocate n elements. All data is lost,
+ // but elements can be accessed in range 0...size-1.
+ void allocate(unsigned size, unsigned extra_tail=0);
+
+ // Resize keeping the content.
+ void resize(unsigned new_size);
+
+ void zero()
+ {
+ memset(m_array, 0, sizeof(T) * m_size);
+ }
+
+ void add(const T& v) { m_array[m_size++] = v; }
+ void push_back(const T& v) { m_array[m_size++] = v; }
+ void insert_at(unsigned pos, const T& val);
+ void inc_size(unsigned size) { m_size += size; }
+ unsigned size() const { return m_size; }
+ unsigned byte_size() const { return m_size * sizeof(T); }
+ void serialize(int8u* ptr) const;
+ void deserialize(const int8u* data, unsigned byte_size);
+ const T& operator [] (unsigned i) const { return m_array[i]; }
+ T& operator [] (unsigned i) { return m_array[i]; }
+ const T& at(unsigned i) const { return m_array[i]; }
+ T& at(unsigned i) { return m_array[i]; }
+ T value_at(unsigned i) const { return m_array[i]; }
+
+ const T* data() const { return m_array; }
+ T* data() { return m_array; }
+
+ void remove_all() { m_size = 0; }
+ void clear() { m_size = 0; }
+ void cut_at(unsigned num) { if(num < m_size) m_size = num; }
+
+ private:
+ unsigned m_size;
+ unsigned m_capacity;
+ T* m_array;
+ };
+
+ //------------------------------------------------------------------------
+ template<class T>
+ void pod_vector<T>::capacity(unsigned cap, unsigned extra_tail)
+ {
+ m_size = 0;
+ if(cap > m_capacity)
+ {
+ pod_allocator<T>::deallocate(m_array, m_capacity);
+ m_capacity = cap + extra_tail;
+ m_array = m_capacity ? pod_allocator<T>::allocate(m_capacity) : 0;
+ }
+ }
+
+ //------------------------------------------------------------------------
+ template<class T>
+ void pod_vector<T>::allocate(unsigned size, unsigned extra_tail)
+ {
+ capacity(size, extra_tail);
+ m_size = size;
+ }
+
+
+ //------------------------------------------------------------------------
+ template<class T>
+ void pod_vector<T>::resize(unsigned new_size)
+ {
+ if(new_size > m_size)
+ {
+ if(new_size > m_capacity)
+ {
+ T* data = pod_allocator<T>::allocate(new_size);
+ memcpy(data, m_array, m_size * sizeof(T));
+ pod_allocator<T>::deallocate(m_array, m_capacity);
+ m_array = data;
+ }
+ }
+ else
+ {
+ m_size = new_size;
+ }
+ }
+
+ //------------------------------------------------------------------------
+ template<class T> pod_vector<T>::pod_vector(unsigned cap, unsigned extra_tail) :
+ m_size(0),
+ m_capacity(cap + extra_tail),
+ m_array(pod_allocator<T>::allocate(m_capacity)) {}
+
+ //------------------------------------------------------------------------
+ template<class T> pod_vector<T>::pod_vector(const pod_vector<T>& v) :
+ m_size(v.m_size),
+ m_capacity(v.m_capacity),
+ m_array(v.m_capacity ? pod_allocator<T>::allocate(v.m_capacity) : 0)
+ {
+ memcpy(m_array, v.m_array, sizeof(T) * v.m_size);
+ }
+
+ //------------------------------------------------------------------------
+ template<class T> const pod_vector<T>&
+ pod_vector<T>::operator = (const pod_vector<T>&v)
+ {
+ allocate(v.m_size);
+ if(v.m_size) memcpy(m_array, v.m_array, sizeof(T) * v.m_size);
+ return *this;
+ }
+
+ //------------------------------------------------------------------------
+ template<class T> void pod_vector<T>::serialize(int8u* ptr) const
+ {
+ if(m_size) memcpy(ptr, m_array, m_size * sizeof(T));
+ }
+
+ //------------------------------------------------------------------------
+ template<class T>
+ void pod_vector<T>::deserialize(const int8u* data, unsigned byte_size)
+ {
+ byte_size /= sizeof(T);
+ allocate(byte_size);
+ if(byte_size) memcpy(m_array, data, byte_size * sizeof(T));
+ }
+
+ //------------------------------------------------------------------------
+ template<class T>
+ void pod_vector<T>::insert_at(unsigned pos, const T& val)
+ {
+ if(pos >= m_size)
+ {
+ m_array[m_size] = val;
+ }
+ else
+ {
+ memmove(m_array + pos + 1, m_array + pos, (m_size - pos) * sizeof(T));
+ m_array[pos] = val;
+ }
+ ++m_size;
+ }
+
+ //---------------------------------------------------------------pod_bvector
+ // A simple class template to store Plain Old Data, similar to std::deque
+ // It doesn't reallocate memory but instead, uses blocks of data of size
+ // of (1 << S), that is, power of two. The data is NOT contiguous in memory,
+ // so the only valid access method is operator [] or curr(), prev(), next()
+ //
+ // There reallocs occure only when the pool of pointers to blocks needs
+ // to be extended (it happens very rarely). You can control the value
+ // of increment to reallocate the pointer buffer. See the second constructor.
+ // By default, the incremeent value equals (1 << S), i.e., the block size.
+ //------------------------------------------------------------------------
+ template<class T, unsigned S=6> class pod_bvector
+ {
+ public:
+ enum block_scale_e
+ {
+ block_shift = S,
+ block_size = 1 << block_shift,
+ block_mask = block_size - 1
+ };
+
+ typedef T value_type;
+
+ ~pod_bvector();
+ pod_bvector();
+ pod_bvector(unsigned block_ptr_inc);
+
+ // Copying
+ pod_bvector(const pod_bvector<T, S>& v);
+ const pod_bvector<T, S>& operator = (const pod_bvector<T, S>& v);
+
+ void remove_all() { m_size = 0; }
+ void clear() { m_size = 0; }
+ void free_all() { free_tail(0); }
+ void free_tail(unsigned size);
+ void add(const T& val);
+ void push_back(const T& val) { add(val); }
+ void modify_last(const T& val);
+ void remove_last();
+
+ int allocate_continuous_block(unsigned num_elements);
+
+ void add_array(const T* ptr, unsigned num_elem)
+ {
+ while(num_elem--)
+ {
+ add(*ptr++);
+ }
+ }
+
+ template<class DataAccessor> void add_data(DataAccessor& data)
+ {
+ while(data.size())
+ {
+ add(*data);
+ ++data;
+ }
+ }
+
+ void cut_at(unsigned size)
+ {
+ if(size < m_size) m_size = size;
+ }
+
+ unsigned size() const { return m_size; }
+
+ const T& operator [] (unsigned i) const
+ {
+ return m_blocks[i >> block_shift][i & block_mask];
+ }
+
+ T& operator [] (unsigned i)
+ {
+ return m_blocks[i >> block_shift][i & block_mask];
+ }
+
+ const T& at(unsigned i) const
+ {
+ return m_blocks[i >> block_shift][i & block_mask];
+ }
+
+ T& at(unsigned i)
+ {
+ return m_blocks[i >> block_shift][i & block_mask];
+ }
+
+ T value_at(unsigned i) const
+ {
+ return m_blocks[i >> block_shift][i & block_mask];
+ }
+
+ const T& curr(unsigned idx) const
+ {
+ return (*this)[idx];
+ }
+
+ T& curr(unsigned idx)
+ {
+ return (*this)[idx];
+ }
+
+ const T& prev(unsigned idx) const
+ {
+ return (*this)[(idx + m_size - 1) % m_size];
+ }
+
+ T& prev(unsigned idx)
+ {
+ return (*this)[(idx + m_size - 1) % m_size];
+ }
+
+ const T& next(unsigned idx) const
+ {
+ return (*this)[(idx + 1) % m_size];
+ }
+
+ T& next(unsigned idx)
+ {
+ return (*this)[(idx + 1) % m_size];
+ }
+
+ const T& last() const
+ {
+ return (*this)[m_size - 1];
+ }
+
+ T& last()
+ {
+ return (*this)[m_size - 1];
+ }
+
+ unsigned byte_size() const;
+ void serialize(int8u* ptr) const;
+ void deserialize(const int8u* data, unsigned byte_size);
+ void deserialize(unsigned start, const T& empty_val,
+ const int8u* data, unsigned byte_size);
+
+ template<class ByteAccessor>
+ void deserialize(ByteAccessor data)
+ {
+ remove_all();
+ unsigned elem_size = data.size() / sizeof(T);
+
+ for(unsigned i = 0; i < elem_size; ++i)
+ {
+ int8u* ptr = (int8u*)data_ptr();
+ for(unsigned j = 0; j < sizeof(T); ++j)
+ {
+ *ptr++ = *data;
+ ++data;
+ }
+ ++m_size;
+ }
+ }
+
+ template<class ByteAccessor>
+ void deserialize(unsigned start, const T& empty_val, ByteAccessor data)
+ {
+ while(m_size < start)
+ {
+ add(empty_val);
+ }
+
+ unsigned elem_size = data.size() / sizeof(T);
+ for(unsigned i = 0; i < elem_size; ++i)
+ {
+ int8u* ptr;
+ if(start + i < m_size)
+ {
+ ptr = (int8u*)(&((*this)[start + i]));
+ }
+ else
+ {
+ ptr = (int8u*)data_ptr();
+ ++m_size;
+ }
+ for(unsigned j = 0; j < sizeof(T); ++j)
+ {
+ *ptr++ = *data;
+ ++data;
+ }
+ }
+ }
+
+ const T* block(unsigned nb) const { return m_blocks[nb]; }
+
+ private:
+ void allocate_block(unsigned nb);
+ T* data_ptr();
+
+ unsigned m_size;
+ unsigned m_num_blocks;
+ unsigned m_max_blocks;
+ T** m_blocks;
+ unsigned m_block_ptr_inc;
+ };
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S> pod_bvector<T, S>::~pod_bvector()
+ {
+ if(m_num_blocks)
+ {
+ T** blk = m_blocks + m_num_blocks - 1;
+ while(m_num_blocks--)
+ {
+ pod_allocator<T>::deallocate(*blk, block_size);
+ --blk;
+ }
+ }
+ pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
+ }
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ void pod_bvector<T, S>::free_tail(unsigned size)
+ {
+ if(size < m_size)
+ {
+ unsigned nb = (size + block_mask) >> block_shift;
+ while(m_num_blocks > nb)
+ {
+ pod_allocator<T>::deallocate(m_blocks[--m_num_blocks], block_size);
+ }
+ if(m_num_blocks == 0)
+ {
+ pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
+ m_blocks = 0;
+ m_max_blocks = 0;
+ }
+ m_size = size;
+ }
+ }
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S> pod_bvector<T, S>::pod_bvector() :
+ m_size(0),
+ m_num_blocks(0),
+ m_max_blocks(0),
+ m_blocks(0),
+ m_block_ptr_inc(block_size)
+ {
+ }
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ pod_bvector<T, S>::pod_bvector(unsigned block_ptr_inc) :
+ m_size(0),
+ m_num_blocks(0),
+ m_max_blocks(0),
+ m_blocks(0),
+ m_block_ptr_inc(block_ptr_inc)
+ {
+ }
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ pod_bvector<T, S>::pod_bvector(const pod_bvector<T, S>& v) :
+ m_size(v.m_size),
+ m_num_blocks(v.m_num_blocks),
+ m_max_blocks(v.m_max_blocks),
+ m_blocks(v.m_max_blocks ?
+ pod_allocator<T*>::allocate(v.m_max_blocks) :
+ 0),
+ m_block_ptr_inc(v.m_block_ptr_inc)
+ {
+ unsigned i;
+ for(i = 0; i < v.m_num_blocks; ++i)
+ {
+ m_blocks[i] = pod_allocator<T>::allocate(block_size);
+ memcpy(m_blocks[i], v.m_blocks[i], block_size * sizeof(T));
+ }
+ }
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ const pod_bvector<T, S>&
+ pod_bvector<T, S>::operator = (const pod_bvector<T, S>& v)
+ {
+ unsigned i;
+ for(i = m_num_blocks; i < v.m_num_blocks; ++i)
+ {
+ allocate_block(i);
+ }
+ for(i = 0; i < v.m_num_blocks; ++i)
+ {
+ memcpy(m_blocks[i], v.m_blocks[i], block_size * sizeof(T));
+ }
+ m_size = v.m_size;
+ return *this;
+ }
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ void pod_bvector<T, S>::allocate_block(unsigned nb)
+ {
+ if(nb >= m_max_blocks)
+ {
+ T** new_blocks = pod_allocator<T*>::allocate(m_max_blocks + m_block_ptr_inc);
+
+ if(m_blocks)
+ {
+ memcpy(new_blocks,
+ m_blocks,
+ m_num_blocks * sizeof(T*));
+
+ pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
+ }
+ m_blocks = new_blocks;
+ m_max_blocks += m_block_ptr_inc;
+ }
+ m_blocks[nb] = pod_allocator<T>::allocate(block_size);
+ m_num_blocks++;
+ }
+
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ inline T* pod_bvector<T, S>::data_ptr()
+ {
+ unsigned nb = m_size >> block_shift;
+ if(nb >= m_num_blocks)
+ {
+ allocate_block(nb);
+ }
+ return m_blocks[nb] + (m_size & block_mask);
+ }
+
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ inline void pod_bvector<T, S>::add(const T& val)
+ {
+ *data_ptr() = val;
+ ++m_size;
+ }
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ inline void pod_bvector<T, S>::remove_last()
+ {
+ if(m_size) --m_size;
+ }
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ void pod_bvector<T, S>::modify_last(const T& val)
+ {
+ remove_last();
+ add(val);
+ }
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ int pod_bvector<T, S>::allocate_continuous_block(unsigned num_elements)
+ {
+ if(num_elements < block_size)
+ {
+ data_ptr(); // Allocate initial block if necessary
+ unsigned rest = block_size - (m_size & block_mask);
+ unsigned index;
+ if(num_elements <= rest)
+ {
+ // The rest of the block is good, we can use it
+ //-----------------
+ index = m_size;
+ m_size += num_elements;
+ return index;
+ }
+
+ // New block
+ //---------------
+ m_size += rest;
+ data_ptr();
+ index = m_size;
+ m_size += num_elements;
+ return index;
+ }
+ return -1; // Impossible to allocate
+ }
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ unsigned pod_bvector<T, S>::byte_size() const
+ {
+ return m_size * sizeof(T);
+ }
+
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ void pod_bvector<T, S>::serialize(int8u* ptr) const
+ {
+ unsigned i;
+ for(i = 0; i < m_size; i++)
+ {
+ memcpy(ptr, &(*this)[i], sizeof(T));
+ ptr += sizeof(T);
+ }
+ }
+
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ void pod_bvector<T, S>::deserialize(const int8u* data, unsigned byte_size)
+ {
+ remove_all();
+ byte_size /= sizeof(T);
+ for(unsigned i = 0; i < byte_size; ++i)
+ {
+ T* ptr = data_ptr();
+ memcpy(ptr, data, sizeof(T));
+ ++m_size;
+ data += sizeof(T);
+ }
+ }
+
+
+ // Replace or add a number of elements starting from "start" position
+ //------------------------------------------------------------------------
+ template<class T, unsigned S>
+ void pod_bvector<T, S>::deserialize(unsigned start, const T& empty_val,
+ const int8u* data, unsigned byte_size)
+ {
+ while(m_size < start)
+ {
+ add(empty_val);
+ }
+
+ byte_size /= sizeof(T);
+ for(unsigned i = 0; i < byte_size; ++i)
+ {
+ if(start + i < m_size)
+ {
+ memcpy(&((*this)[start + i]), data, sizeof(T));
+ }
+ else
+ {
+ T* ptr = data_ptr();
+ memcpy(ptr, data, sizeof(T));
+ ++m_size;
+ }
+ data += sizeof(T);
+ }
+ }
+
+
+ //---------------------------------------------------------block_allocator
+ // Allocator for arbitrary POD data. Most usable in different cache
+ // systems for efficient memory allocations.
+ // Memory is allocated with blocks of fixed size ("block_size" in
+ // the constructor). If required size exceeds the block size the allocator
+ // creates a new block of the required size. However, the most efficient
+ // use is when the average reqired size is much less than the block size.
+ //------------------------------------------------------------------------
+ class block_allocator
+ {
+ struct block_type
+ {
+ int8u* data;
+ unsigned size;
+ };
+
+ public:
+ void remove_all()
+ {
+ if(m_num_blocks)
+ {
+ block_type* blk = m_blocks + m_num_blocks - 1;
+ while(m_num_blocks--)
+ {
+ pod_allocator<int8u>::deallocate(blk->data, blk->size);
+ --blk;
+ }
+ pod_allocator<block_type>::deallocate(m_blocks, m_max_blocks);
+ }
+ m_num_blocks = 0;
+ m_max_blocks = 0;
+ m_blocks = 0;
+ m_buf_ptr = 0;
+ m_rest = 0;
+ }
+
+ ~block_allocator()
+ {
+ remove_all();
+ }
+
+ block_allocator(unsigned block_size, unsigned block_ptr_inc=256-8) :
+ m_block_size(block_size),
+ m_block_ptr_inc(block_ptr_inc),
+ m_num_blocks(0),
+ m_max_blocks(0),
+ m_blocks...
[truncated message content] |
