public static IAffineTransformMatrix <T> NewScaling(VectorDimension dimension, T s)
{
IAffineTransformMatrix <T> a = MatrixFactory <T> .NewIdentity(dimension);
a.Scale(s);
return(a);
}
public static IAffineTransformMatrix <T> NewScaling(IVector <T> scaleVector)
{
IAffineTransformMatrix <T> a = MatrixFactory <T> .NewIdentity(scaleVector.RowCount);
a.Scale(scaleVector);
return(a);
}
public static IAffineTransformMatrix <T> NewTranslation(IVector <T> translationVector)
{
IAffineTransformMatrix <T> a = MatrixFactory <T> .NewIdentity(translationVector.RowCount);
a.Translate(translationVector, MatrixOperationOrder.Append);
return(a);
}
public static IAffineTransformMatrix <T> NewTranslation(T dx, T dy, T dz)
{
IAffineTransformMatrix <T> a = MatrixFactory <T> .NewIdentity(VectorDimension.Three);
a.Translate(MatrixFactory <T> .CreateVector3D(dx, dy, dz));
return(a);
}
public static IAffineTransformMatrix <T> NewRotation(VectorDimension dimension, double r)
{
IAffineTransformMatrix <T> a = MatrixFactory <T> .NewIdentity(dimension);
a.RotateAlong(MatrixFactory <T> .CreateZeroVector(dimension), r);
return(a);
}
public override void OnDraw()
{
base.OnDraw();
if (m_ShowFrameRate)
{
T GraphOffsetY = M.New <T>(-105);
if (m_ShowPotentialDrawsBudgetGraph.status())
{
IAffineTransformMatrix <T> Position = MatrixFactory <T> .NewTranslation(M.Zero <T>(), GraphOffsetY);
m_PotentialDrawsBudgetGraph.Draw(Position, GetRenderer());
}
if (m_ShowPotentialUpdatesBudgetGraph.status())
{
IAffineTransformMatrix <T> Position = MatrixFactory <T> .NewTranslation(M.Zero <T>(), GraphOffsetY);
m_PotentialUpdatesBudgetGraph.Draw(Position, GetRenderer());
}
if (m_ShowActualDrawsBudgetGraph.status())
{
IAffineTransformMatrix <T> Position = MatrixFactory <T> .NewTranslation(M.Zero <T>(), GraphOffsetY);
m_ActualDrawsBudgetGraph.Draw(Position, GetRenderer());
}
}
}
public override void OnKeyDown(AGG.UI.KeyEventArgs keyEvent)
{
if (keyEvent.KeyCode == Keys.Space)
{
T cx = m_quad.xn(0).Add(m_quad.xn(1)).Add(m_quad.xn(2)).Add(m_quad.xn(3)).Divide(4);
T cy = m_quad.yn(0).Add(m_quad.yn(1)).Add(m_quad.yn(2)).Add(m_quad.yn(3)).Divide(4);
IAffineTransformMatrix <T> tr = MatrixFactory <T> .NewTranslation(cx.Negative(), cy.Negative());
tr.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), (Math.PI / 2.0));
tr.Translate(MatrixFactory <T> .CreateVector2D(cx, cy));
T xn0 = m_quad.xn(0); T yn0 = m_quad.yn(0);
T xn1 = m_quad.xn(1); T yn1 = m_quad.yn(1);
T xn2 = m_quad.xn(2); T yn2 = m_quad.yn(2);
T xn3 = m_quad.xn(3); T yn3 = m_quad.yn(3);
tr.Transform(ref xn0, ref yn0);
tr.Transform(ref xn1, ref yn1);
tr.Transform(ref xn2, ref yn2);
tr.Transform(ref xn3, ref yn3);
m_quad.SetXN(0, xn0); m_quad.SetYN(0, yn0);
m_quad.SetXN(1, xn1); m_quad.SetYN(1, yn1);
m_quad.SetXN(2, xn2); m_quad.SetYN(2, yn2);
m_quad.SetXN(3, xn3); m_quad.SetYN(3, yn3);
force_redraw();
}
base.OnKeyDown(keyEvent);
}
public override void Render(IVertexSource <T> vertexSource, uint pathIndexToRender, RGBA_Bytes colorBytes)
{
#if use_timers
OpenGLRenderTimer.Start();
#endif
PushOrthoProjection();
vertexSource.Rewind(pathIndexToRender);
RGBA_Doubles color = colorBytes.GetAsRGBA_Doubles();
Gl.glColor4d(color.R, color.G, color.B, color.A);
IAffineTransformMatrix <T> transform = GetTransform();
if (!transform.Equals(MatrixFactory <T> .NewIdentity(VectorDimension.Two)))
{
vertexSource = new ConvTransform <T>(vertexSource, transform);
}
if (m_ForceTexturedEdgeAntiAliasing)
{
DrawAAShape(vertexSource);
}
else
{
SendShapeToTeselator(m_RenderNowTesselator, vertexSource);
}
PopOrthoProjection();
#if use_timers
OpenGLRenderTimer.Stop();
#endif
}
public static void CreateContext(RasterBuffer renderingBuffer)
{
// set the rendering buffer and all the GL default states (this is also where you can new anything you need)
s_RenderingBuffer = renderingBuffer;
s_Rasterizer.SetVectorClipBox(M.Zero <T>(), M.Zero <T>(), M.New <T>(s_RenderingBuffer.Width), M.New <T>(s_RenderingBuffer.Height));
s_PixelFormt = new FormatRGBA(s_RenderingBuffer, new BlenderBGRA());
s_ClippingPixelFormatProxy = new FormatClippingProxy(s_PixelFormt);
//s_ClippingPixelFormatProxy = s_PixelFormt;
m_CurAccumulatedMatrix = MatrixFactory <T> .NewIdentity(VectorDimension.Three); // new Matrix4X4();
m_ModelviewMatrix = MatrixFactory <T> .NewIdentity(VectorDimension.Three); // new Matrix4X4();
m_ProjectionMatrix = MatrixFactory <T> .NewIdentity(VectorDimension.Three); //new Matrix4X4();
m_pVertexCache = new VertexCachItem[m_MaxVertexCacheItems];
for (int i = 0; i < m_MaxVertexCacheItems; i++)
{
m_pVertexCache[i] = new VertexCachItem();
}
m_LastSetColor = new RGBA_Doubles(1, 1, 1, 1);
m_LastSetNormal = MatrixFactory <T> .CreateZeroVector(VectorDimension.Three); // new Vector3D();
m_LastSetTextureCoordinate = MatrixFactory <T> .CreateZeroVector(VectorDimension.Two); // new Vector2D();
}
public static IAffineTransformMatrix <T> NewRotation(IVector <T> axis, double r)
{
IAffineTransformMatrix <T> a = MatrixFactory <T> .NewIdentity(axis.RowCount);
a.RotateAlong(axis, r);
return(a);
}
public virtual void OnDraw()
{
for (int i = 0; i < m_Children.Count; i++)
{
GUIWidget <T> child = m_Children[i];
if (child.Visible)
{
GetRenderer().PushTransform();
//Affine transform = GetRenderer().GetTransform();
//transform *= child.GetTransform();
IAffineTransformMatrix <T> transform = GetRenderer().GetTransform();
transform = MatrixFactory <T> .CreateAffine(transform.Multiply(child.GetTransform()));
//transform *= child.GetTransform();
GetRenderer().SetTransform(transform);
child.OnDraw();
#if false
if (Focused)
{
RoundedRect rect = new RoundedRect(-5, -5, 5, 5, 0);
GetRenderer().Render(rect, new RGBA_Bytes(1.0, 0, 0, .5));
}
#endif
GetRenderer().PopTransform();
}
}
}
public TextEditWidget(string Text, RectDouble <T> bounds, T CapitalHeight)
{
Bounds = bounds;
m_TextWidget = new TextWidget <T>(Text, M.Zero <T>(), M.Zero <T>(), CapitalHeight);
AddChild(m_TextWidget);
m_CharIndexToInsertBefore = Text.Length;
IAffineTransformMatrix <T> transform = GetTransform();
IVector <T> v1 = transform.TransformVector(MatrixFactory <T> .CreateVector2D(bounds.x1, bounds.y1));
IVector <T> v2 = transform.TransformVector(MatrixFactory <T> .CreateVector2D(bounds.x2, bounds.y2));
SetTransform(transform);
m_BorderSize = CapitalHeight.Multiply(.2);
m_Thickness = CapitalHeight.Divide(8);
m_CapsHeight = CapitalHeight;
FixBarPosition(true);
UndoData newUndoData = new UndoData(this);
m_UndoBuffer.Add(newUndoData, "Initial", UndoBuffer.MergeType.NotMergable);
}
public static void Transform <T>(this IAffineTransformMatrix <T> m, ref T x, ref T y)
where T : IEquatable <T>, IComparable <T>, IComputable <T>, IConvertible, IFormattable, ICommonNumericalOperations <T>, ITrigonometricOperations <T>
{
IVector <T> v1 = m.TransformVector(MatrixFactory <T> .CreateVector2D(x, y));
x = v1[0];
y = v1[1];
}
protected override void DoDraw(RendererBase <T> destRenderer)
{
IAffineTransformMatrix <T> Final = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
Final.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), m_Rotation.ToDouble());
Final.Translate(m_Position);
ConvTransform <T> TransformedShip = new ConvTransform <T>(m_PlayerToDraw, Final);
destRenderer.Render(TransformedShip, new RGBA_Bytes(.9, .4, .2, 1));
}
public override void Render(IVertexSource<T> vertexSource, uint pathIndexToRender, RGBA_Bytes colorBytes)
{
m_Rasterizer.Reset();
IAffineTransformMatrix<T> transform = GetTransform();
if (!transform.Equals(MatrixFactory<T>.NewIdentity(VectorDimension.Two)))
{
vertexSource = new ConvTransform<T>(vertexSource, transform);
}
m_Rasterizer.AddPath(vertexSource, pathIndexToRender);
Renderer<T>.RenderSolid(m_PixelFormat, m_Rasterizer, m_ScanlineCache, colorBytes);
}
//-------------------------------------------------------------------
public IAffineTransformMatrix <T> ToAffine()
{
//Affine mtx = Affine.NewTranslation(-m_wx1, -m_wy1);
//mtx *= Affine.NewScaling(m_kx, m_ky);
//mtx *= Affine.NewTranslation(m_dx1, m_dy1);
//return mtx;
IAffineTransformMatrix <T> a = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
a.Translate(MatrixFactory <T> .CreateVector2D(m_wx1.Negative(), m_wy1.Negative()));
a.Scale(MatrixFactory <T> .CreateVector2D(m_kx, m_ky));
a.Scale(MatrixFactory <T> .CreateVector2D(m_dx1, m_dy1));
return(a);
}
void DrawAATest()
{
PathStorage <T> PolgonToDraw = new PathStorage <T>();
T Angle = M.Zero <T>();
bool DrawTrinagle = true;
if (DrawTrinagle)
{
PolgonToDraw.MoveTo(Angle.Cos(), Angle.Sin());
Angle.AddEquals(120.0 / 180.0 * Math.PI);
PolgonToDraw.LineTo(Angle.Cos(), Angle.Sin());
Angle.AddEquals(120.0 / 180.0 * Math.PI);
PolgonToDraw.LineTo(Angle.Cos(), Angle.Sin());
Angle.AddEquals(120.0 / 180.0 * Math.PI);
//Triangle.line_to(Math.Cos(Angle), Math.Sin(Angle));
PolgonToDraw.ClosePolygon();
}
else
{
PolgonToDraw.MoveTo(M.Zero <T>(), M.Zero <T>());
PolgonToDraw.LineTo(M.One <T>(), M.Zero <T>());
PolgonToDraw.LineTo(M.One <T>(), M.One <T>());
PolgonToDraw.LineTo(M.Zero <T>(), M.One <T>());
PolgonToDraw.ClosePolygon();
}
IAffineTransformMatrix <T> tran = MatrixFactory <T> .NewScaling(VectorDimension.Two, M.New <T>(80));
tran.RotateAlong(MatrixFactory <T> .CreateVector2D(M.Zero <T>(), M.Zero <T>()), Math.PI / 8);
tran.Translate(MatrixFactory <T> .CreateVector2D(M.New <T>(500), M.New <T>(100)));
ConvTransform <T> TransformedPolygon = new ConvTransform <T>(PolgonToDraw, tran);
((RendererOpenGL <T>)GetRenderer()).m_ForceTexturedEdgeAntiAliasing = true;
GetRenderer().Render(TransformedPolygon, new RGBA_Bytes(0, 0, 0));
Ellipse <T> testEllipse = new Ellipse <T>(M.New <T>(300), M.New <T>(250), M.New <T>(60), M.New <T>(60));
GetRenderer().Render(testEllipse, new RGBA_Bytes(205, 23, 12, 120));
((RendererOpenGL <T>)GetRenderer()).m_ForceTexturedEdgeAntiAliasing = false;
//conv_stroke OutLine = new conv_stroke(TransformedPolygon);
//OutLine.width(2);
//conv_transform TransformedOutLine = new conv_transform(OutLine, Affine.NewTranslation(100, 0));
//GetRenderer().Render(TransformedOutLine, new RGBA_Bytes(0, 0, 0));
//conv_transform TransformedOutLine2 = new conv_transform(OutLine, Affine.NewScaling(6) * Affine.NewTranslation(200, 0));
//conv_stroke OutLineOutLine = new conv_stroke(TransformedOutLine2);
//GetRenderer().Render(OutLineOutLine, new RGBA_Bytes(0, 0, 0));
}
public void TransformTest()
{
IAffineTransformMatrix <DoubleComponent> a = MatrixFactory <DoubleComponent> .NewIdentity(VectorDimension.Two);
a.Translate(MatrixFactory <DoubleComponent> .CreateVector2D(10, 20));
DoubleComponent x = 10;
DoubleComponent y = 20;
DoubleComponent newx = 0;
DoubleComponent newy = 0;
a.Transform(ref newx, ref newy);
Assert.AreEqual((double)x, (double)newx, .001);
Assert.AreEqual((double)y, (double)newy, .001);
}
public static void glMatrixMode(int mode)
{
switch (mode)
{
case GL_MODELVIEW:
m_CurEditingMatrix = m_ModelviewMatrix;
break;
case GL_PROJECTION:
m_CurEditingMatrix = m_ProjectionMatrix;
break;
default:
throw new System.NotImplementedException("You have to have one of the matrices we suport");
}
}
public static T TranslationY <T>(this IAffineTransformMatrix <T> m)
where T : IEquatable <T>, IComparable <T>, IComputable <T>, IConvertible, IFormattable, ICommonNumericalOperations <T>, ITrigonometricOperations <T>
{
if (m.ColumnCount != 3)
{
throw new InvalidOperationException();
}
if (m.Format == MatrixFormat.RowMajor)
{
return(m[2, 1]);
}
else
{
return(m[1, 2]);
}
}
public override void OnDraw()
{
int width = (int)rbuf_window().Width;
int height = (int)rbuf_window().Height;
IPixelFormat pixf = new FormatRGB(rbuf_window(), new BlenderBGR());
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
clippingProxy.Clear(new RGBA_Doubles(1, 1, 1));
IAffineTransformMatrix <T> mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
mtx.Translate(MatrixFactory <T> .CreateVector2D(g_base_dx.Negative(), g_base_dy.Negative()));
mtx.Scale(g_scale);
mtx.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), g_angle.Add(Math.PI).ToDouble());
mtx.Shear(MatrixFactory <T> .CreateVector2D(g_skew_x.Divide(1000.0), g_skew_y.Divide(1000.0)));
mtx.Translate(MatrixFactory <T> .CreateVector2D(width / 2, height / 2));
if (m_scanline.status())
{
g_rasterizer.SetVectorClipBox(0, 0, width, height);
ConvStroke <T> stroke = new ConvStroke <T>(g_path);
stroke.Width = m_width_slider.value();
stroke.LineJoin = LineJoin.RoundJoin;
ConvTransform <T> trans = new ConvTransform <T>(stroke, mtx);
Renderer <T> .RenderSolidAllPaths(clippingProxy, g_rasterizer, g_scanline, trans, g_colors, g_path_idx, g_npaths);
}
else
{
/*
* double w = m_width_slider.Value() * mtx.scale();
*
* line_profile_aa profile = new line_profile_aa(w, new gamma_none());
* renderer_outline_aa ren = new renderer_outline_aa(rb, profile);
* rasterizer_outline_aa ras = new rasterizer_outline_aa(ren);
*
* conv_transform trans = new conv_transform(g_path, mtx);
*
* ras.render_all_paths(trans, g_colors, g_path_idx, g_npaths);
*/
}
base.OnDraw();
}
//used to Transform the sweepers vertices prior to rendering
public void WorldTransform(List <IVector <T> > sweeper)
{
////create the world transformation matrix
//Matrix4X4 matTransform = new Matrix4X4();
////scale
//matTransform.Scale(m_dScale, m_dScale, 1);
////rotate
//matTransform.AddRotate(2, (double)m_dRotation);
////and translate
//matTransform.AddTranslate(m_vPosition.x, m_vPosition.y, 0);
////now Transform the ships vertices
//for (int i = 0; i < sweeper.Count; i++)
//{
// Vector3D Temp = sweeper[i];
// matTransform.TransformVector(ref Temp);
// sweeper[i] = Temp;
//}
//create the world transformation matrix
IAffineTransformMatrix <T> matTransform = MatrixFactory <T> .NewIdentity(VectorDimension.Three);
//scale
matTransform.Scale(MatrixFactory <T> .CreateVector3D(m_dScale, m_dScale, M.One <T>()));
//rotate
//matTransform.AddRotate(2, (double)m_dRotation);
IVector <T> axis = null;/// need to work out which axis this should be
matTransform.RotateAlong(axis, m_dRotation);
//and translate
matTransform.Translate(MatrixFactory <T> .CreateVector3D(m_vPosition[0], m_vPosition[1], M.Zero <T>()));
//now Transform the ships vertices
for (int i = 0; i < sweeper.Count; i++)
{
IVector <T> Temp = sweeper[i];
Temp = matTransform.TransformVector(Temp);
sweeper[i] = Temp;
}
}
//--------------------------------------------------------------------
public void TransformAllPaths(IAffineTransformMatrix <T> trans)
{
uint idx;
uint num_ver = m_vertices.TotalVertices();
for (idx = 0; idx < num_ver; idx++)
{
T x, y;
if (Path.IsVertex(m_vertices.Vertex(idx, out x, out y)))
{
//trans.Transform(ref x, ref y);
//m_vertices.ModifyVertex(idx, x, y);
IVector <T> v = trans.TransformVector(MatrixFactory <T> .CreateVector2D(x, y));
m_vertices.ModifyVertex(idx, v[0], v[1]);
}
}
}
public override void OnDraw()
{
#if use_timers
AllTimer.Start();
#endif
int width = (int)rbuf_window().Width;
int height = (int)rbuf_window().Height;
uint i;
for (i = 0; i < m_NumPaths; i++)
{
// g_colors[i].A_Byte = (byte)(m_AlphaSlider.value() * 255);
g_colors[i] = RGBA_Bytes.ModifyComponent(g_colors[i], Component.A, (byte)(m_AlphaSlider.value().ToDouble() * 255));
}
IAffineTransformMatrix <T> transform = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
transform.Translate(MatrixFactory <T> .CreateVector2D(g_base_dx.Negative(), g_base_dy.Negative()));
transform.Scale(MatrixFactory <T> .CreateVector2D(g_scale, g_scale));
transform.RotateAlong(MatrixFactory <T> .CreateVector2D(M.Zero <T>(), M.Zero <T>()), g_angle + Math.PI);
transform.Shear(MatrixFactory <T> .CreateVector2D(g_skew_x.Divide(1000.0), g_skew_y.Divide(1000.0)));
transform.Translate(MatrixFactory <T> .CreateVector2D(M.New <T>(width).Divide(2), M.New <T>(height).Divide(2)));
// This code renders the lion:
ConvTransform <T> transformedPathStorage = new ConvTransform <T>(g_PathStorage, transform);
#if use_timers
Lion50Timer.Start();
for (uint j = 0; j < 200; j++)
#endif
{
this.GetRenderer().Render(transformedPathStorage, g_colors, g_path_idx, m_NumPaths);
}
#if use_timers
Lion50Timer.Stop();
#endif
#if use_timers
AllTimer.Stop();
CExecutionTimer.Instance.AppendResultsToFile("TimingTest.txt", AllTimer.GetTotalSeconds());
CExecutionTimer.Instance.Reset();
#endif
base.OnDraw();
}
public void AlignX(T x, Alignment alignment)
{
IAffineTransformMatrix <T> transform = GetTransform();
switch (alignment)
{
case Alignment.Center:
SetTransform(MatrixFactory <T> .NewTranslation(x.Subtract(Width.Divide(2)), transform.TranslationY()));
break;
case Alignment.Left:
SetTransform(MatrixFactory <T> .NewTranslation(x, transform.TranslationY()));
break;
case Alignment.Right:
SetTransform(MatrixFactory <T> .NewTranslation(x.Subtract(Width), transform.TranslationY()));
break;
}
}
public void WorldTransform(List <IVector <T> > VBuffer, IVector <T> vPos)
{
//create the world transformation matrix
//Matrix4X4 matTransform = new Matrix4X4();
IAffineTransformMatrix <T> matTransform = MatrixFactory <T> .NewIdentity(VectorDimension.Three);
//scale
matTransform.Scale(MatrixFactory <T> .CreateVector2D(m_MineScale, m_MineScale));
//translate
matTransform.Translate(MatrixFactory <T> .CreateVector2D(vPos[0], vPos[1]));
//Transform the ships vertices
for (int i = 0; i < VBuffer.Count; i++)
{
IVector <T> Temp = VBuffer[i];
Temp = matTransform.TransformVector(Temp);
VBuffer[i] = Temp;
}
}
public void Transform(IAffineTransformMatrix <T> trans, uint path_id)
{
uint num_ver = m_vertices.TotalVertices();
for (; path_id < num_ver; path_id++)
{
T x, y;
uint PathAndFlags = m_vertices.Vertex(path_id, out x, out y);
if (Path.IsStop(PathAndFlags))
{
break;
}
if (Path.IsVertex(PathAndFlags))
{
//trans.Transform(ref x, ref y);
//m_vertices.ModifyVertex(path_id, x, y);
IVector <T> v1 = trans.TransformVector(MatrixFactory <T> .CreateVector2D(x, y));
m_vertices.ModifyVertex(path_id, v1[0], v1[1]);
}
}
}
public static void glBegin(int mode)
{
//m_CurAccumulatedMatrix.Multiply(m_ModelviewMatrix, m_ProjectionMatrix);
m_CurAccumulatedMatrix = (IAffineTransformMatrix <T>)m_CurAccumulatedMatrix.Multiply(m_ModelviewMatrix);
m_CurAccumulatedMatrix = (IAffineTransformMatrix <T>)m_CurAccumulatedMatrix.Multiply(m_ProjectionMatrix);
switch (mode)
{
case GL_TRIANGLES:
s_BeginMode = GL_TRIANGLES;
break;
case GL_QUADS:
s_BeginMode = GL_QUADS;
break;
default:
throw new System.NotImplementedException();
}
}
public void InvertTest()
{
//Affine a = Affine.NewIdentity();
IAffineTransformMatrix <DoubleComponent> a =
MatrixFactory <DoubleComponent> .NewIdentity(VectorDimension.Two);
a.Translate(
MatrixFactory <DoubleComponent> .CreateVector2D(
M.New <DoubleComponent>(10),
M.New <DoubleComponent>(10)));
IAffineTransformMatrix <DoubleComponent> b = MatrixFactory <DoubleComponent> .CreateAffine(a);
b = b.Inverse;
DoubleComponent x = 100;
DoubleComponent y = 100;
DoubleComponent newx = x;
DoubleComponent newy = y;
IVector <DoubleComponent> v1 =
MatrixFactory <DoubleComponent> .CreateVector2D(
M.New <DoubleComponent>(100),
M.New <DoubleComponent>(100));
IVector <DoubleComponent> v2 = a.TransformVector(v1);
IVector <DoubleComponent> v3 = b.TransformVector(v2);
//a.Transform(ref newx, ref newy);
//b.Transform(ref newx, ref newy);
Assert.AreEqual((double)v1[0], (double)v3[0], .001);
Assert.AreEqual((double)v1[1], (double)v3[1], .001);
}
void transform_image(double angle)
{
double width = rbuf_img(0).Width;
double height = rbuf_img(0).Height;
#if SourceDepth24
FormatRGB pixf = new FormatRGB(rbuf_img(0), new BlenderBGR());
FormatRGB pixf_pre = new FormatRGB(rbuf_img(0), new BlenderPreMultBGR());
#else
pixfmt_alpha_blend_rgba32 pixf = new pixfmt_alpha_blend_rgba32(rbuf_img(0), new blender_bgra32());
pixfmt_alpha_blend_rgba32 pixf_pre = new pixfmt_alpha_blend_rgba32(rbuf_img(0), new blender_bgra_pre());
#endif
FormatClippingProxy rb = new FormatClippingProxy(pixf);
FormatClippingProxy rb_pre = new FormatClippingProxy(pixf_pre);
rb.Clear(new RGBA_Doubles(1.0, 1.0, 1.0));
IAffineTransformMatrix <T> src_mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
src_mtx.Translate(MatrixFactory <T> .CreateVector2D(-width / 2.0, -height / 2.0));
src_mtx.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), angle * Math.PI / 180.0);
src_mtx.Translate(MatrixFactory <T> .CreateVector2D(width / 2.0, height / 2.0));
IAffineTransformMatrix <T> img_mtx = MatrixFactory <T> .CreateAffine(src_mtx);
img_mtx = img_mtx.Inverse;
double r = width;
if (height < r)
{
r = height;
}
r *= 0.5;
r -= 4.0;
VertexSource.Ellipse <T> ell = new AGG.VertexSource.Ellipse <T>(width / 2.0, height / 2.0, r, r, 200);
ConvTransform <T> tr = new ConvTransform <T>(ell, src_mtx);
m_num_pix += r * r * Math.PI;
SpanInterpolatorLinear <T> interpolator = new SpanInterpolatorLinear <T>(img_mtx);
ImageFilterLookUpTable <T> filter = new ImageFilterLookUpTable <T>();
bool norm = m_normalize.status();
#if SourceDepth24
FormatRGB pixf_img = new FormatRGB(rbuf_img(1), new BlenderBGR());
#else
pixfmt_alpha_blend_rgba32 pixf_img = new pixfmt_alpha_blend_rgba32(rbuf_img(1), new blender_bgra32());
#endif
RasterBufferAccessorClip source = new RasterBufferAccessorClip(pixf_img, RGBA_Doubles.RgbaPre(0, 0, 0, 0));
switch (m_filters.cur_item())
{
case 0:
{
#if SourceDepth24
SpanImageFilterRgbNN <T> sg = new SpanImageFilterRgbNN <T>(source, interpolator);
#else
span_image_filter_rgba_nn sg = new span_image_filter_rgba_nn(source, interpolator);
#endif
m_Rasterizer.AddPath(tr);
Renderer <T> .GenerateAndRender(m_Rasterizer, m_ScanlineUnpacked, rb_pre, m_SpanAllocator, sg);
}
break;
case 1:
{
#if SourceDepth24
//span_image_filter_rgb_bilinear_clip sg = new span_image_filter_rgb_bilinear_clip(pixf_img, rgba.rgba_pre(0, 0.4, 0, 0.5), interpolator);
SpanImageFilterRgbBilinear <T> sg = new SpanImageFilterRgbBilinear <T>(source, interpolator);
#else
//span_image_filter_rgba_bilinear_clip sg = new span_image_filter_rgba_bilinear_clip(pixf_img, rgba.rgba_pre(0, 0, 0, 0), interpolator);
span_image_filter_rgba_bilinear sg = new span_image_filter_rgba_bilinear(source, interpolator);
#endif
m_Rasterizer.AddPath(tr);
Renderer <T> .GenerateAndRender(m_Rasterizer, m_ScanlineUnpacked, rb_pre, m_SpanAllocator, sg);
}
break;
case 5:
case 6:
case 7:
{
switch (m_filters.cur_item())
{
case 5: filter.Calculate(new ImageFilterHanning <T>(), norm); break;
case 6: filter.Calculate(new ImageFilterHamming <T>(), norm); break;
case 7: filter.Calculate(new ImageFilterHermite <T>(), norm); break;
}
SpanImageFilterRgb2x2 <T> sg = new SpanImageFilterRgb2x2 <T>(source, interpolator, filter);
m_Rasterizer.AddPath(tr);
Renderer <T> .GenerateAndRender(m_Rasterizer, m_ScanlineUnpacked, rb_pre, m_SpanAllocator, sg);
}
break;
case 2:
case 3:
case 4:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
{
switch (m_filters.cur_item())
{
case 2: filter.Calculate(new ImageFilterBicubic <T>(), norm); break;
case 3: filter.Calculate(new ImageFilterSpline16 <T>(), norm); break;
case 4: filter.Calculate(new ImageFilterSpline36 <T>(), norm); break;
case 8: filter.Calculate(new ImageFilterKaiser <T>(), norm); break;
case 9: filter.Calculate(new ImageFilterQuadric <T>(), norm); break;
case 10: filter.Calculate(new ImageFilterCatrom <T>(), norm); break;
case 11: filter.Calculate(new ImageFilterGaussian <T>(), norm); break;
case 12: filter.Calculate(new ImageFilterBessel <T>(), norm); break;
case 13: filter.Calculate(new ImageFilterMitchell <T>(), norm); break;
case 14: filter.Calculate(new ImageFilterSinc <T>(m_radius.value()), norm); break;
case 15: filter.Calculate(new ImageFilterLanczos <T>(m_radius.value()), norm); break;
case 16:
filter.Calculate(new ImageFilterBlackman <T>(m_radius.value()), norm);
break;
}
#if SourceDepth24
SpanImageFilterRgb <T> sg = new SpanImageFilterRgb <T>(source, interpolator, filter);
#else
span_image_filter_rgb sg = new span_image_filter_rgba(source, interpolator, filter);
#endif
m_Rasterizer.AddPath(tr);
Renderer <T> .GenerateAndRender(m_Rasterizer, m_ScanlineUnpacked, rb_pre, m_SpanAllocator, sg);
}
break;
}
}
