summaryrefslogtreecommitdiff
path: root/agg/inc/agg_span_interpolator_persp.h
diff options
context:
space:
mode:
Diffstat (limited to 'agg/inc/agg_span_interpolator_persp.h')
-rwxr-xr-xagg/inc/agg_span_interpolator_persp.h462
1 files changed, 462 insertions, 0 deletions
diff --git a/agg/inc/agg_span_interpolator_persp.h b/agg/inc/agg_span_interpolator_persp.h
new file mode 100755
index 000000000000..632a56449f28
--- /dev/null
+++ b/agg/inc/agg_span_interpolator_persp.h
@@ -0,0 +1,462 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.3
+// 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: mcseem@antigrain.com
+// mcseemagg@yahoo.com
+// http://www.antigrain.com
+//----------------------------------------------------------------------------
+#ifndef AGG_SPAN_INTERPOLATOR_PERSP_INCLUDED
+#define AGG_SPAN_INTERPOLATOR_PERSP_INCLUDED
+
+#include "agg_trans_perspective.h"
+#include "agg_dda_line.h"
+
+namespace agg
+{
+
+
+
+ //===========================================span_interpolator_persp_exact
+ template<unsigned SubpixelShift = 8>
+ class span_interpolator_persp_exact
+ {
+ public:
+ typedef trans_perspective trans_type;
+ typedef trans_perspective::iterator_x iterator_type;
+ enum
+ {
+ subpixel_shift = SubpixelShift,
+ subpixel_size = 1 << subpixel_shift
+ };
+
+ //--------------------------------------------------------------------
+ span_interpolator_persp_exact() {}
+
+ //--------------------------------------------------------------------
+ // Arbitrary quadrangle transformations
+ span_interpolator_persp_exact(const double* src, const double* dst)
+ {
+ quad_to_quad(src, dst);
+ }
+
+ //--------------------------------------------------------------------
+ // Direct transformations
+ span_interpolator_persp_exact(double x1, double y1,
+ double x2, double y2,
+ const double* quad)
+ {
+ rect_to_quad(x1, y1, x2, y2, quad);
+ }
+
+ //--------------------------------------------------------------------
+ // Reverse transformations
+ span_interpolator_persp_exact(const double* quad,
+ double x1, double y1,
+ double x2, double y2)
+ {
+ quad_to_rect(quad, x1, y1, x2, y2);
+ }
+
+ //--------------------------------------------------------------------
+ // Set the transformations using two arbitrary quadrangles.
+ void quad_to_quad(const double* src, const double* dst)
+ {
+ m_trans_dir.quad_to_quad(src, dst);
+ m_trans_inv.quad_to_quad(dst, src);
+ }
+
+ //--------------------------------------------------------------------
+ // Set the direct transformations, i.e., rectangle -> quadrangle
+ void rect_to_quad(double x1, double y1, double x2, double y2,
+ const double* quad)
+ {
+ double src[8];
+ src[0] = src[6] = x1;
+ src[2] = src[4] = x2;
+ src[1] = src[3] = y1;
+ src[5] = src[7] = y2;
+ quad_to_quad(src, quad);
+ }
+
+
+ //--------------------------------------------------------------------
+ // Set the reverse transformations, i.e., quadrangle -> rectangle
+ void quad_to_rect(const double* quad,
+ double x1, double y1, double x2, double y2)
+ {
+ double dst[8];
+ dst[0] = dst[6] = x1;
+ dst[2] = dst[4] = x2;
+ dst[1] = dst[3] = y1;
+ dst[5] = dst[7] = y2;
+ quad_to_quad(quad, dst);
+ }
+
+ //--------------------------------------------------------------------
+ // Check if the equations were solved successfully
+ bool is_valid() const { return m_trans_dir.is_valid(); }
+
+ //----------------------------------------------------------------
+ void begin(double x, double y, unsigned len)
+ {
+ m_iterator = m_trans_dir.begin(x, y, 1.0);
+ double xt = m_iterator.x;
+ double yt = m_iterator.y;
+
+ double dx;
+ double dy;
+ const double delta = 1/double(subpixel_size);
+ dx = xt + delta;
+ dy = yt;
+ m_trans_inv.transform(&dx, &dy);
+ dx -= x;
+ dy -= y;
+ int sx1 = int(subpixel_size/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
+ dx = xt;
+ dy = yt + delta;
+ m_trans_inv.transform(&dx, &dy);
+ dx -= x;
+ dy -= y;
+ int sy1 = int(subpixel_size/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
+
+ x += len;
+ xt = x;
+ yt = y;
+ m_trans_dir.transform(&xt, &yt);
+
+ dx = xt + delta;
+ dy = yt;
+ m_trans_inv.transform(&dx, &dy);
+ dx -= x;
+ dy -= y;
+ int sx2 = int(subpixel_size/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
+ dx = xt;
+ dy = yt + delta;
+ m_trans_inv.transform(&dx, &dy);
+ dx -= x;
+ dy -= y;
+ int sy2 = int(subpixel_size/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
+
+ m_scale_x = dda2_line_interpolator(sx1, sx2, len);
+ m_scale_y = dda2_line_interpolator(sy1, sy2, len);
+ }
+
+
+ //----------------------------------------------------------------
+ void resynchronize(double xe, double ye, unsigned len)
+ {
+ // Assume x1,y1 are equal to the ones at the previous end point
+ int sx1 = m_scale_x.y();
+ int sy1 = m_scale_y.y();
+
+ // Calculate transformed coordinates at x2,y2
+ double xt = xe;
+ double yt = ye;
+ m_trans_dir.transform(&xt, &yt);
+
+ const double delta = 1/double(subpixel_size);
+ double dx;
+ double dy;
+
+ // Calculate scale by X at x2,y2
+ dx = xt + delta;
+ dy = yt;
+ m_trans_inv.transform(&dx, &dy);
+ dx -= xe;
+ dy -= ye;
+ int sx2 = int(subpixel_size/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
+
+ // Calculate scale by Y at x2,y2
+ dx = xt;
+ dy = yt + delta;
+ m_trans_inv.transform(&dx, &dy);
+ dx -= xe;
+ dy -= ye;
+ int sy2 = int(subpixel_size/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
+
+ // Initialize the interpolators
+ m_scale_x = dda2_line_interpolator(sx1, sx2, len);
+ m_scale_y = dda2_line_interpolator(sy1, sy2, len);
+ }
+
+
+
+ //----------------------------------------------------------------
+ void operator++()
+ {
+ ++m_iterator;
+ ++m_scale_x;
+ ++m_scale_y;
+ }
+
+ //----------------------------------------------------------------
+ void coordinates(int* x, int* y) const
+ {
+ *x = int(m_iterator.x * subpixel_size + 0.5);
+ *y = int(m_iterator.y * subpixel_size + 0.5);
+ }
+
+ //----------------------------------------------------------------
+ void local_scale(int* x, int* y)
+ {
+ *x = m_scale_x.y();
+ *y = m_scale_y.y();
+ }
+
+ //----------------------------------------------------------------
+ void transform(double* x, double* y) const
+ {
+ m_trans_dir.transform(x, y);
+ }
+
+ private:
+ trans_type m_trans_dir;
+ trans_type m_trans_inv;
+ iterator_type m_iterator;
+ dda2_line_interpolator m_scale_x;
+ dda2_line_interpolator m_scale_y;
+ };
+
+
+
+
+
+
+
+
+
+
+
+ //============================================span_interpolator_persp_lerp
+ template<unsigned SubpixelShift = 8>
+ class span_interpolator_persp_lerp
+ {
+ public:
+ typedef trans_perspective trans_type;
+ enum
+ {
+ subpixel_shift = SubpixelShift,
+ subpixel_size = 1 << subpixel_shift
+ };
+
+ //--------------------------------------------------------------------
+ span_interpolator_persp_lerp() {}
+
+ //--------------------------------------------------------------------
+ // Arbitrary quadrangle transformations
+ span_interpolator_persp_lerp(const double* src, const double* dst)
+ {
+ quad_to_quad(src, dst);
+ }
+
+ //--------------------------------------------------------------------
+ // Direct transformations
+ span_interpolator_persp_lerp(double x1, double y1,
+ double x2, double y2,
+ const double* quad)
+ {
+ rect_to_quad(x1, y1, x2, y2, quad);
+ }
+
+ //--------------------------------------------------------------------
+ // Reverse transformations
+ span_interpolator_persp_lerp(const double* quad,
+ double x1, double y1,
+ double x2, double y2)
+ {
+ quad_to_rect(quad, x1, y1, x2, y2);
+ }
+
+ //--------------------------------------------------------------------
+ // Set the transformations using two arbitrary quadrangles.
+ void quad_to_quad(const double* src, const double* dst)
+ {
+ m_trans_dir.quad_to_quad(src, dst);
+ m_trans_inv.quad_to_quad(dst, src);
+ }
+
+ //--------------------------------------------------------------------
+ // Set the direct transformations, i.e., rectangle -> quadrangle
+ void rect_to_quad(double x1, double y1, double x2, double y2,
+ const double* quad)
+ {
+ double src[8];
+ src[0] = src[6] = x1;
+ src[2] = src[4] = x2;
+ src[1] = src[3] = y1;
+ src[5] = src[7] = y2;
+ quad_to_quad(src, quad);
+ }
+
+
+ //--------------------------------------------------------------------
+ // Set the reverse transformations, i.e., quadrangle -> rectangle
+ void quad_to_rect(const double* quad,
+ double x1, double y1, double x2, double y2)
+ {
+ double dst[8];
+ dst[0] = dst[6] = x1;
+ dst[2] = dst[4] = x2;
+ dst[1] = dst[3] = y1;
+ dst[5] = dst[7] = y2;
+ quad_to_quad(quad, dst);
+ }
+
+ //--------------------------------------------------------------------
+ // Check if the equations were solved successfully
+ bool is_valid() const { return m_trans_dir.is_valid(); }
+
+ //----------------------------------------------------------------
+ void begin(double x, double y, unsigned len)
+ {
+ // Calculate transformed coordinates at x1,y1
+ double xt = x;
+ double yt = y;
+ m_trans_dir.transform(&xt, &yt);
+ int x1 = int(xt * subpixel_size);
+ int y1 = int(yt * subpixel_size);
+
+ double dx;
+ double dy;
+ const double delta = 1/double(subpixel_size);
+
+ // Calculate scale by X at x1,y1
+ dx = xt + delta;
+ dy = yt;
+ m_trans_inv.transform(&dx, &dy);
+ dx -= x;
+ dy -= y;
+ int sx1 = int(subpixel_size/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
+
+ // Calculate scale by Y at x1,y1
+ dx = xt;
+ dy = yt + delta;
+ m_trans_inv.transform(&dx, &dy);
+ dx -= x;
+ dy -= y;
+ int sy1 = int(subpixel_size/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
+
+ // Calculate transformed coordinates at x2,y2
+ x += len;
+ xt = x;
+ yt = y;
+ m_trans_dir.transform(&xt, &yt);
+ int x2 = int(xt * subpixel_size);
+ int y2 = int(yt * subpixel_size);
+
+ // Calculate scale by X at x2,y2
+ dx = xt + delta;
+ dy = yt;
+ m_trans_inv.transform(&dx, &dy);
+ dx -= x;
+ dy -= y;
+ int sx2 = int(subpixel_size/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
+
+ // Calculate scale by Y at x2,y2
+ dx = xt;
+ dy = yt + delta;
+ m_trans_inv.transform(&dx, &dy);
+ dx -= x;
+ dy -= y;
+ int sy2 = int(subpixel_size/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
+
+ // Initialize the interpolators
+ m_coord_x = dda2_line_interpolator(x1, x2, len);
+ m_coord_y = dda2_line_interpolator(y1, y2, len);
+ m_scale_x = dda2_line_interpolator(sx1, sx2, len);
+ m_scale_y = dda2_line_interpolator(sy1, sy2, len);
+ }
+
+
+ //----------------------------------------------------------------
+ void resynchronize(double xe, double ye, unsigned len)
+ {
+ // Assume x1,y1 are equal to the ones at the previous end point
+ int x1 = m_coord_x.y();
+ int y1 = m_coord_y.y();
+ int sx1 = m_scale_x.y();
+ int sy1 = m_scale_y.y();
+
+ // Calculate transformed coordinates at x2,y2
+ double xt = xe;
+ double yt = ye;
+ m_trans_dir.transform(&xt, &yt);
+ int x2 = int(xt * subpixel_size);
+ int y2 = int(yt * subpixel_size);
+
+ const double delta = 1/double(subpixel_size);
+ double dx;
+ double dy;
+
+ // Calculate scale by X at x2,y2
+ dx = xt + delta;
+ dy = yt;
+ m_trans_inv.transform(&dx, &dy);
+ dx -= xe;
+ dy -= ye;
+ int sx2 = int(subpixel_size/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
+
+ // Calculate scale by Y at x2,y2
+ dx = xt;
+ dy = yt + delta;
+ m_trans_inv.transform(&dx, &dy);
+ dx -= xe;
+ dy -= ye;
+ int sy2 = int(subpixel_size/sqrt(dx*dx + dy*dy)) >> subpixel_shift;
+
+ // Initialize the interpolators
+ m_coord_x = dda2_line_interpolator(x1, x2, len);
+ m_coord_y = dda2_line_interpolator(y1, y2, len);
+ m_scale_x = dda2_line_interpolator(sx1, sx2, len);
+ m_scale_y = dda2_line_interpolator(sy1, sy2, len);
+ }
+
+
+ //----------------------------------------------------------------
+ void operator++()
+ {
+ ++m_coord_x;
+ ++m_coord_y;
+ ++m_scale_x;
+ ++m_scale_y;
+ }
+
+ //----------------------------------------------------------------
+ void coordinates(int* x, int* y) const
+ {
+ *x = m_coord_x.y();
+ *y = m_coord_y.y();
+ }
+
+ //----------------------------------------------------------------
+ void local_scale(int* x, int* y)
+ {
+ *x = m_scale_x.y();
+ *y = m_scale_y.y();
+ }
+
+ //----------------------------------------------------------------
+ void transform(double* x, double* y) const
+ {
+ m_trans_dir.transform(x, y);
+ }
+
+ private:
+ trans_type m_trans_dir;
+ trans_type m_trans_inv;
+ dda2_line_interpolator m_coord_x;
+ dda2_line_interpolator m_coord_y;
+ dda2_line_interpolator m_scale_x;
+ dda2_line_interpolator m_scale_y;
+ };
+
+}
+
+#endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-18 16:08:40 +0000