public unsafe void CanPinMatrixPointers()
{
var m1 = MatrixFactory.Create <float>(2, 3);
var m2 = MatrixFactory.Create <float>(2, 3);
var ptrs = new MatrixPointersBag <float>(m1, m2);
var p1 = ptrs[0];
var p2 = ptrs[1];
GC.Collect();
ptrs[0].ShouldEqual(p1);
ptrs[1].ShouldEqual(p2);
fixed(void *fp1 = &m1.AsColumnMajorArray()[0], fp2 = &m2.AsColumnMajorArray()[0])
{
(p1.ToPointer() == fp1).ShouldBeTrue();
(p2.ToPointer() == fp2).ShouldBeTrue();
}
ptrs.Dispose();
}
/// <summary>
/// Transforms a given polycurve in the local coordsys to global.
/// </summary>
/// <param name="curveInLocal">Curve in local coordinates.</param>
/// <returns>The transformed polycurve in global coordinates.</returns>
private Polycurve TransformToGlobal(Polycurve curveInLocal)
{
var coordSys = GetBaseCoordsys(this.BaseCentroid, this.Normal);
var toGlobal = MatrixFactory.FromCoordinateSystem(coordSys);
var transformedCurves = curveInLocal.Select(c => TransformGeometryByMatrix(c, toGlobal));
var builder = new PolycurveGeometryBuilder();
foreach (var curve in transformedCurves)
{
if (curve is Arc arc)
{
builder.Append(arc);
}
else if (curve is LineSegment segment)
{
builder.Append(segment);
}
}
return(builder.GetPolycurve());
}
public void HouseholderTridiagonalizeTest()
{
Matrix matrix = MatrixFactory.CreateSquare(4, 1, -2, 2,
1, 2, 0, 1,
-2, 0, 3, -2,
2, 1, -2, -1);
Matrix expected = MatrixFactory.CreateSquare(4, -3, 0, 0,
-3, 10.0 / 3, -5.0 / 3, 0,
0, -5.0 / 3, -33.0 / 25, 68.0 / 75,
0, 0, 68.0 / 75, 149.0 / 75);
Matrix tridiag = HouseholderTransformation.Tridiagonalize(matrix);
for (Int32 j = 0; j < matrix.NumberOfRows; j++)
{
for (Int32 k = 0; k < matrix.NumberOfColumns; k++)
{
Assert.AreEqual(expected[j, k], tridiag[j, k], 0.01);
}
}
}
public void CreateExtrusion(DbElement owner, IfcObjectGeometryData primitive, bool chamfers)
{
DbElement dbElement1 = owner.Create(0, (DbElementType)DbElementTypeInstance.EXTRUSION);
try
{
Vector xdirTs = primitive.XDirTS;
xdirTs.Normalize();
Vector ydirTs = primitive.YDirTS;
ydirTs.Normalize();
CoordinateSystem CoordSys = new CoordinateSystem(primitive.PolygonPointsTS[0], xdirTs, ydirTs);
Matrix matrix = MatrixFactory.ToCoordinateSystem(CoordSys);
Orientation orientation = Tools.CreateOrientation(xdirTs, ydirTs);
Position pos = Position.Create(CoordSys.Origin.X, CoordSys.Origin.Y, CoordSys.Origin.Z);
Tools.CreatePosOri(dbElement1, pos, orientation);
double num1 = Math.Round(Distance.PointToPoint(primitive.StartPointTS, primitive.EndPointTS), 0);
Tools.SetAttribute(dbElement1, (DbAttribute)DbAttributeInstance.HEIG, num1);
DbElement dbElement2 = dbElement1.Create(0, (DbElementType)DbElementTypeInstance.LOOP);
int index = 0;
List <Point> points;
List <double> chamfers1;
new PolygonCreator().GetPolygonPointsArcMiddelePoint(primitive, out points, out chamfers1);
List <Point> list = points.Select <Point, Point>((Func <Point, Point>)(p => matrix.Transform(p))).ToList <Point>();
Tools.CleanPolygonImport(ref chamfers1, ref list);
foreach (Point point in list)
{
DbElement element = dbElement2.Create(0, (DbElementType)DbElementTypeInstance.VERTEX);
Tools.SetAttribute(element, (DbAttribute)DbAttributeInstance.POS, Position.Create(point.X, point.Y, point.Z));
double num2 = chamfers ? Math.Floor(chamfers1[index]) : 0.0;
Tools.SetAttribute(element, (DbAttribute)DbAttributeInstance.FRAD, num2);
++index;
}
}
catch
{
dbElement1.Delete();
}
}
//returns a List to the closest mine
public IVector <T> GetClosestMine(List <IVector <T> > mines)
{
T closest_so_far = M.New <T>(99999);
IVector <T> vClosestObject = MatrixFactory <T> .CreateZeroVector(VectorDimension.Three);
//cycle through mines to find closest
for (int i = 0; i < mines.Count; i++)
{
T len_to_object = mines[i].Subtract(m_vPosition).GetMagnitude();
if (len_to_object.LessThan(closest_so_far))
{
closest_so_far = len_to_object;
vClosestObject = m_vPosition.Subtract(mines[i]);
m_iClosestMine = i;
}
}
return(vClosestObject);
}
public void CanTransferWeightThroughNeuroWeightRowMajor()
{
var weight = MatrixFactory.RandomMatrix <float>(2, 3, 5.0f);
var local = new NeuroWeight <float>(weight);
var remote = local.Clone();
MutateMatrixRowMajor(local.Weight);
MutateMatrixRowMajor(local.Gradient);
MutateMatrixRowMajor(local.Cache1);
MutateMatrixRowMajor(local.Cache2);
MutateMatrixRowMajor(local.CacheM);
using (var ptrs = new WeightDefinitionBag <float>(true, remote))
{
GpuInterface.Testing.TestComplexWeightTransferRowMajor(ptrs.Definitions[0]);
}
local.Weight.ShouldMatrixEqualWithinError(remote.Weight);
local.Gradient.ShouldMatrixEqualWithinError(remote.Gradient);
local.Cache1.ShouldMatrixEqualWithinError(remote.Cache1);
local.Cache2.ShouldMatrixEqualWithinError(remote.Cache2);
local.CacheM.ShouldMatrixEqualWithinError(remote.CacheM);
}
public static NeuroWeight <T> Load(Stream stream)
{
var result = new NeuroWeight <T>();
using (var reader = new BinaryReader(stream, Encoding.UTF8, true))
{
result.Weight = MatrixFactory.Load <T>(stream);
bool saveCache = reader.ReadBoolean();
bool saveGrad = reader.ReadBoolean();
if (saveCache)
{
result.Cache1 = MatrixFactory.Load <T>(stream);
result.Cache2 = MatrixFactory.Load <T>(stream);
result.CacheM = MatrixFactory.Load <T>(stream);
result.Timestep = reader.ReadInt32();
}
else
{
result.Cache1 = Matrix <T> .Build.Dense(result.Weight.RowCount, result.Weight.ColumnCount);
result.Cache2 = Matrix <T> .Build.Dense(result.Weight.RowCount, result.Weight.ColumnCount);
result.CacheM = Matrix <T> .Build.Dense(result.Weight.RowCount, result.Weight.ColumnCount);
}
if (saveGrad)
{
result.Gradient = MatrixFactory.Load <T>(stream);
}
else
{
result.Gradient = Matrix <T> .Build.Dense(result.Weight.RowCount, result.Weight.ColumnCount);
}
}
return(result);
}
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;
}
}
public void MatrixMultiplicationTest()
{
// multiply with scalar
Double scalar = Math.PI;
for (Int32 i = 0; i < this.matrices.Length; i++)
{
Matrix product = scalar * this.matrices[i];
for (Int32 rowIndex = 0; rowIndex < product.NumberOfRows; rowIndex++)
{
for (Int32 columnIndex = 0; columnIndex < product.NumberOfColumns; columnIndex++)
{
product[rowIndex, columnIndex].ShouldBe(scalar * this.matrices[i][rowIndex, columnIndex]);
}
}
product = this.matrices[i] * scalar;
for (Int32 rowIndex = 0; rowIndex < product.NumberOfRows; rowIndex++)
{
for (Int32 columnIndex = 0; columnIndex < product.NumberOfColumns; columnIndex++)
{
product[rowIndex, columnIndex].ShouldBe(scalar * this.matrices[i][rowIndex, columnIndex]);
}
}
}
// multiply with matrix
Matrix[] expectedMultiple = new Matrix[]
{
MatrixFactory.CreateSquare(),
MatrixFactory.CreateSquare(0),
MatrixFactory.CreateSquare(0.25, 0, 0, 0.25),
MatrixFactory.CreateSquare(12, 20, 26,
17, 29, 38,
3, 7, 12),
MatrixFactory.CreateSquare(206, 562, 728, 102,
34, 98, 112, 40,
106, 423, 437, 127,
50, 167, 191, 42)
};
for (Int32 i = 0; i < 4; i++)
{
Matrix mulMatrix = this.matrices[i] * this.matrices[i];
for (Int32 rowIndex = 0; rowIndex < mulMatrix.NumberOfRows; rowIndex++)
{
for (Int32 columnIndex = 0; columnIndex < mulMatrix.NumberOfColumns; columnIndex++)
{
mulMatrix[rowIndex, columnIndex].ShouldBe(expectedMultiple[i][rowIndex, columnIndex]);
}
}
}
Matrix matrix = null;
Should.Throw <ArgumentNullException>(() => matrix = 1 * matrix);
Should.Throw <ArgumentNullException>(() => matrix = matrix * 1);
Should.Throw <ArgumentNullException>(() => matrix = this.matrices[3] * matrix);
Should.Throw <ArgumentNullException>(() => matrix = matrix * this.matrices[3]);
Should.Throw <ArgumentException>(() => matrix = this.matrices[3] * this.matrices[6]);
}
public static void glVertex3f(T x, T y, T z)
{
IVector <T> WorldPoint = MatrixFactory <T> .CreateVector3D(x, y, z);
WorldPoint = m_CurAccumulatedMatrix.TransformVector(WorldPoint);
T OneOverZ = M.One <T>().Divide(WorldPoint[2]);
WorldPoint[0] = WorldPoint[0].Multiply(OneOverZ).Add(1).Multiply(s_GLViewport.X2 * .5f).Add(s_GLViewport.X1);
WorldPoint[1] = WorldPoint[1].Multiply(OneOverZ).Add(1).Multiply(s_GLViewport.Y2 * .5f).Add(s_GLViewport.Y1);
m_pVertexCache[m_NumCachedVertex].m_Position = WorldPoint;
m_pVertexCache[m_NumCachedVertex].m_Color = m_LastSetColor;
m_pVertexCache[m_NumCachedVertex].m_Normal = m_LastSetNormal;
m_pVertexCache[m_NumCachedVertex].m_TextureCoordinate = m_LastSetTextureCoordinate;
m_NumCachedVertex++;
//double Dilation = 0;
T Dilation = M.New <T>(.175);
switch (s_BeginMode)
{
/*
* case GL_POINTS:
* {
* RenderLine(m_pVertexCache[0].m_Position, m_pVertexCache[0].m_Position, m_LastSetColor);
* m_NumCachedVertex3fs = 0;
* }
* break;
*
* case LINES:
* {
* if(m_NumCachedVertex3fs == 2)
* {
* // <WIP> use both vertex colors LBB [1/14/2002]
* RenderLine(m_pVertexCache[0].m_Position, m_pVertexCache[1].m_Position, m_pVertexCache[0].m_Color);
* m_NumCachedVertex3fs = 0;
* }
* }
* break;
*/
case GL_TRIANGLES:
if (m_NumCachedVertex == 3)
{
IVector <T> Winding = VectorUtilities <T> .Cross(
m_pVertexCache[1].m_Position.Subtract(m_pVertexCache[0].m_Position),
m_pVertexCache[2].m_Position.Subtract(m_pVertexCache[0].m_Position));
if (Winding[2].GreaterThan(0))
{
s_GouraudSpanGen.Colors(m_pVertexCache[0].m_Color,
m_pVertexCache[1].m_Color,
m_pVertexCache[2].m_Color);
s_GouraudSpanGen.Triangle(m_pVertexCache[0].m_Position[0], m_pVertexCache[0].m_Position[1],
m_pVertexCache[1].m_Position[0], m_pVertexCache[1].m_Position[1],
m_pVertexCache[2].m_Position[0], m_pVertexCache[2].m_Position[1], Dilation);
s_Rasterizer.AddPath(s_GouraudSpanGen);
//s_Rasterizer.gamma(new gamma_linear(0.0, 0.809));
//renderer_scanlines.render_scanlines_aa_solid(ras, sl, ren_base, m_pVertexCache[0].m_Color.Get_rgba8());
Renderer <T> .GenerateAndRender(s_Rasterizer, s_ScanlineUnpacked, s_ClippingPixelFormatProxy, s_SpanAllocator, s_GouraudSpanGen);
}
m_NumCachedVertex = 0;
}
break;
case GL_QUADS:
if (m_NumCachedVertex == 4)
{
IVector <T> Winding = VectorUtilities <T> .Cross(
m_pVertexCache[1].m_Position.Subtract(m_pVertexCache[0].m_Position),
m_pVertexCache[2].m_Position.Subtract(m_pVertexCache[0].m_Position));
if (Winding[2].GreaterThan(0))
{
switch (s_ShadeModel)
{
case GL_FLAT:
// this can be faster if we don't try to shade it (no span generator)
s_SharedPathStorage.RemoveAll();
s_SharedPathStorage.MoveTo(m_pVertexCache[0].m_Position[0], m_pVertexCache[0].m_Position[1]);
s_SharedPathStorage.LineTo(m_pVertexCache[1].m_Position[0], m_pVertexCache[1].m_Position[1]);
s_SharedPathStorage.LineTo(m_pVertexCache[2].m_Position[0], m_pVertexCache[2].m_Position[1]);
s_SharedPathStorage.LineTo(m_pVertexCache[3].m_Position[0], m_pVertexCache[3].m_Position[1]);
s_Rasterizer.AddPath(s_SharedPathStorage);
Renderer <T> .RenderSolid(s_ClippingPixelFormatProxy, s_Rasterizer, s_ScanlineUnpacked, m_pVertexCache[0].m_Color.GetAsRGBA_Bytes());
break;
case GL_SMOOTH:
s_GouraudSpanGen.Colors(
m_pVertexCache[0].m_Color,
m_pVertexCache[1].m_Color,
m_pVertexCache[2].m_Color);
s_GouraudSpanGen.Triangle(
m_pVertexCache[0].m_Position[0], m_pVertexCache[0].m_Position[1],
m_pVertexCache[1].m_Position[0], m_pVertexCache[1].m_Position[1],
m_pVertexCache[2].m_Position[0], m_pVertexCache[2].m_Position[1], Dilation);
s_Rasterizer.AddPath(s_GouraudSpanGen);
//s_Rasterizer.gamma(new gamma_linear(0.0, 0.809));
Renderer <T> .RenderSolid(s_ClippingPixelFormatProxy, s_Rasterizer, s_ScanlineUnpacked, m_pVertexCache[0].m_Color.GetAsRGBA_Bytes());
s_GouraudSpanGen.Colors(
m_pVertexCache[0].m_Color,
m_pVertexCache[2].m_Color,
m_pVertexCache[3].m_Color);
s_GouraudSpanGen.Triangle(
m_pVertexCache[0].m_Position[0], m_pVertexCache[0].m_Position[1],
m_pVertexCache[2].m_Position[0], m_pVertexCache[2].m_Position[1],
m_pVertexCache[3].m_Position[0], m_pVertexCache[3].m_Position[1], M.Zero <T>());
s_Rasterizer.AddPath(s_GouraudSpanGen);
Renderer <T> .RenderSolid(s_ClippingPixelFormatProxy, s_Rasterizer, s_ScanlineUnpacked, m_pVertexCache[0].m_Color.GetAsRGBA_Bytes());
break;
default:
throw new System.NotImplementedException();
}
}
m_NumCachedVertex = 0;
}
break;
default:
// Be sure to call Begin before you pass Vertexes. LBB [1/12/2002]
throw new System.NotImplementedException("You do not have a mode set or you have an invalid mode. LBB [1/12/2002]");
}
}
public blur_application(PixelFormats format, ERenderOrigin RenderOrigin)
: base(format, RenderOrigin)
{
m_rbuf2 = new RasterBuffer();
m_shape_bounds = new RectDouble <T>();
m_method = new rbox_ctrl <T>(10.0, 10.0, 130.0, 70.0);
m_radius = new SliderWidget <T>(130 + 10.0, 10.0 + 4.0, 130 + 300.0, 10.0 + 8.0 + 4.0);
m_shadow_ctrl = new polygon_ctrl <T>(4);
m_channel_r = new cbox_ctrl <T>(10.0, 80.0, "Red");
m_channel_g = new cbox_ctrl <T>(10.0, 95.0, "Green");
m_channel_b = new cbox_ctrl <T>(10.0, 110.0, "Blue");
m_FlattenCurves = new cbox_ctrl <T>(10, 315, "Convert And Flatten Curves");
m_FlattenCurves.status(true);
AddChild(m_method);
m_method.text_size(8);
m_method.add_item("Stack Blur");
m_method.add_item("Recursive Blur");
m_method.add_item("Channels");
m_method.cur_item(1);
AddChild(m_radius);
m_radius.range(0.0, 40.0);
m_radius.value(15.0);
m_radius.label("Blur Radius={0:F2}");
AddChild(m_shadow_ctrl);
AddChild(m_channel_r);
AddChild(m_channel_g);
AddChild(m_channel_b);
AddChild(m_FlattenCurves);
m_channel_g.status(true);
m_sl = new ScanlinePacked8();
m_path = new PathStorage <T>();
m_shape = new ConvCurve <T>(m_path);
m_path.RemoveAll();
m_path.MoveTo(28.47, 6.45);
m_path.Curve3(21.58, 1.12, 19.82, 0.29);
m_path.Curve3(17.19, -0.93, 14.21, -0.93);
m_path.Curve3(9.57, -0.93, 6.57, 2.25);
m_path.Curve3(3.56, 5.42, 3.56, 10.60);
m_path.Curve3(3.56, 13.87, 5.03, 16.26);
m_path.Curve3(7.03, 19.58, 11.99, 22.51);
m_path.Curve3(16.94, 25.44, 28.47, 29.64);
m_path.LineTo(28.47, 31.40);
m_path.Curve3(28.47, 38.09, 26.34, 40.58);
m_path.Curve3(24.22, 43.07, 20.17, 43.07);
m_path.Curve3(17.09, 43.07, 15.28, 41.41);
m_path.Curve3(13.43, 39.75, 13.43, 37.60);
m_path.LineTo(13.53, 34.77);
m_path.Curve3(13.53, 32.52, 12.38, 31.30);
m_path.Curve3(11.23, 30.08, 9.38, 30.08);
m_path.Curve3(7.57, 30.08, 6.42, 31.35);
m_path.Curve3(5.27, 32.62, 5.27, 34.81);
m_path.Curve3(5.27, 39.01, 9.57, 42.53);
m_path.Curve3(13.87, 46.04, 21.63, 46.04);
m_path.Curve3(27.59, 46.04, 31.40, 44.04);
m_path.Curve3(34.28, 42.53, 35.64, 39.31);
m_path.Curve3(36.52, 37.21, 36.52, 30.71);
m_path.LineTo(36.52, 15.53);
m_path.Curve3(36.52, 9.13, 36.77, 7.69);
m_path.Curve3(37.01, 6.25, 37.57, 5.76);
m_path.Curve3(38.13, 5.27, 38.87, 5.27);
m_path.Curve3(39.65, 5.27, 40.23, 5.62);
m_path.Curve3(41.26, 6.25, 44.19, 9.18);
m_path.LineTo(44.19, 6.45);
m_path.Curve3(38.72, -0.88, 33.74, -0.88);
m_path.Curve3(31.35, -0.88, 29.93, 0.78);
m_path.Curve3(28.52, 2.44, 28.47, 6.45);
m_path.ClosePolygon();
m_path.MoveTo(28.47, 9.62);
m_path.LineTo(28.47, 26.66);
m_path.Curve3(21.09, 23.73, 18.95, 22.51);
m_path.Curve3(15.09, 20.36, 13.43, 18.02);
m_path.Curve3(11.77, 15.67, 11.77, 12.89);
m_path.Curve3(11.77, 9.38, 13.87, 7.06);
m_path.Curve3(15.97, 4.74, 18.70, 4.74);
m_path.Curve3(22.41, 4.74, 28.47, 9.62);
m_path.ClosePolygon();
IAffineTransformMatrix <T> shape_mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
shape_mtx.Scale(M.New <T>(4.0));
shape_mtx.Translate(MatrixFactory <T> .CreateVector2D(150, 100));
m_path.Transform(shape_mtx);
BoundingRect <T> .BoundingRectSingle(m_shape, 0, ref m_shape_bounds);
m_shadow_ctrl.SetXN(0, m_shape_bounds.x1);
m_shadow_ctrl.SetYN(0, m_shape_bounds.y1);
m_shadow_ctrl.SetXN(1, m_shape_bounds.x2);
m_shadow_ctrl.SetYN(1, m_shape_bounds.y1);
m_shadow_ctrl.SetXN(2, m_shape_bounds.x2);
m_shadow_ctrl.SetYN(2, m_shape_bounds.y2);
m_shadow_ctrl.SetXN(3, m_shape_bounds.x1);
m_shadow_ctrl.SetYN(3, m_shape_bounds.y2);
m_shadow_ctrl.line_color(new RGBA_Doubles(0, 0.3, 0.5, 0.3));
}
public static void Register(string InUsername, string InEmail, int InPIN, DateTime InBirthYear, string InPassword, string InReferer, Gender InGender, Panel CustomFields,
string FirstName, string SecondName, string Address, string City, string StateProvince, string ZipCode, bool isEarner, bool isAdvertiser, bool isPublisher, string FacebookId = null,
bool skipRedirection = false)
{
AppSettings.Email.Reload();
bool IsFromFacebookOAuth = FacebookId != null ? true : false;
// 0. Logged-in check
if (Member.IsLogged)
{
throw new MsgException(U5009.LOGOUTTOREGISTER);
}
// 1. Validate if Username is not taken
if (Member.Exists(InUsername))
{
throw new MsgException(L1.ER_INVALIDUSERNAME3);
}
// Or forbidden
if (!SecurityManager.IsOkWithRules(SecurityRuleType.Username, InUsername) || InUsername.Contains("refback"))
{
throw new MsgException(L1.UNAMEFORBID);
}
// 2. Validate if Email is not taken
if (Member.ExistsWithEmail(InEmail))
{
throw new MsgException(L1.ER_DUPLICATEEMAIL);
}
string currentip = IP.Current;
CountryInformation CIService = new CountryInformation(currentip);
// 0. Validate if Country/IP is not forbidden
if (!SecurityManager.IsOkWithRules(SecurityRuleType.IP, currentip))
{
throw new MsgException(L1.IPFORBID);
}
if (!SecurityManager.IsOkWithRules(SecurityRuleType.Country, CIService.CountryName))
{
throw new MsgException(L1.COUNTRYFORBID);
}
// Validate if IP is not a proxy
if (AppSettings.Proxy.IPPolicy == IPVerificationPolicy.EveryRegistration && ProxyManager.IsProxy(currentip))
{
throw new MsgException(L1.IPAPROXY);
}
if (AppSettings.Site.AllowOnlyOneRegisteredIP)
{
int membersRegisteredWithThisIP = (int)TableHelper.SelectScalar(
String.Format("SELECT COUNT(*) FROM Users WHERE RegisteredWithIP = '{0}'", currentip));
if (membersRegisteredWithThisIP > 0)
{
throw new MsgException(U5005.IPALREADYREGISTERED);
}
}
AppSettings.DemoCheck();
//Validate if country is OK
FeatureManager Manager = null;
if (IsFromFacebookOAuth)
{
Manager = new FeatureManager(GeolocatedFeatureType.FacebookRegistration);
}
else
{
Manager = new FeatureManager(GeolocatedFeatureType.Registration);
}
if (!Manager.IsAllowed)
{
throw new MsgException(U4000.SORRYCOUNTRY);
}
// All data is OK. Now lets register
Member NewMember = new Member();
NewMember.Name = InUsername;
NewMember.Email = InEmail;
NewMember.PIN = InPIN;
NewMember.BirthYear = InBirthYear;
NewMember.PrimaryPassword = MemberAuthenticationService.ComputeHash(InPassword);
NewMember.FacebookOAuthId = FacebookId;
//Detailed info?
if (AppSettings.Authentication.DetailedRegisterFields)
{
NewMember.FirstName = FirstName;
NewMember.SecondName = SecondName;
NewMember.Address = Address;
NewMember.City = City;
NewMember.StateProvince = StateProvince;
NewMember.ZipCode = ZipCode;
NewMember.Gender = InGender;
}
//Custom fields?
RegistrationFieldCreator.Save(NewMember, CustomFields);
NewMember.CameFromUrl = (HttpContext.Current.Session == null || HttpContext.Current.Session["ReferralFrom"] == null) ? "Unknown" : HttpContext.Current.Session["ReferralFrom"].ToString().Replace("www.", "");
NewMember.Country = CIService.CountryName;
NewMember.CountryCode = CIService.CountryCode;
NewMember.MessageSystemTurnedOn = true;
NewMember.RevenueShareAdsWatchedYesterday = 1000; //No yesterday, that is why we assume that he watched all
NewMember.PointsBalance = 0;
//Slot Machine Modlue
if (AppSettings.TitanFeatures.SlotMachineEnabled)
{
try
{
NewMember.PointsBalance = (int)HttpContext.Current.Session["anonymousSlotMachinePoints"];
}
catch (Exception slotError)
{
NewMember.SlotMachineChances = 1;
ErrorLogger.Log(slotError);
}
}
//Account type
NewMember.IsEarner = isEarner;
NewMember.IsAdvertiser = isAdvertiser;
NewMember.IsPublisher = isPublisher;
// Check if instant register or requires activation
if (AppSettings.Authentication.IsInstantlyActivated || AppSettings.IsDemo || IsFromFacebookOAuth)
{
//Adding referer and points bonus
NewMember.TryAddReferer(InReferer);
//Add history entry
History.AddRegistration(NewMember.Name);
//Representatives policy
TrySetRepresentativeAsReferer(NewMember, CIService);
if (AppSettings.Proxy.SMSType == ProxySMSType.EveryRegistration)
{
NewMember.Register(MemberStatus.AwaitingSMSPIN);
}
else
{
if (NewMember.HasReferer)
{
var list = new List <RestrictionKind>(new RestrictionKind[] { RestrictionKind.DirectReferralsCount });
LeadershipSystem.CheckSystem(list, new Member(NewMember.ReferrerId));
}
NewMember.Register(MemberStatus.Active);
}
//Registration Bonus
TryApplyRegistrationBonus(Manager, NewMember);
//Matrix
MatrixBase matrix = MatrixFactory.GetMatrix();
if (matrix != null)
{
matrix.TryAddMember(NewMember);
}
if (!skipRedirection)
{
HttpContext.Current.Response.Redirect("~/status.aspx?type=registerok&id=register1");
}
}
else
{
try
{
Mailer.SendActivationLink(InUsername, InEmail);
//Representatives policy
TrySetRepresentativeAsReferer(NewMember, CIService);
//Adding referer and points bonus
NewMember.TryAddReferer(InReferer);
NewMember.Register(MemberStatus.Inactive);
//Add history entry
History.AddRegistration(NewMember.Name);
//Registration Bonus
TryApplyRegistrationBonus(Manager, NewMember);
//Matrix
MatrixBase matrix = MatrixFactory.GetMatrix();
if (matrix != null)
{
matrix.TryAddMember(NewMember);
}
}
catch (Exception ex)
{
ErrorLogger.Log(ex);
throw new MsgException("The system was unable to send the activation e-mail. Contact the administrator.");
}
if (!skipRedirection)
{
HttpContext.Current.Response.Redirect("~/status.aspx?type=registerok&id=register2");
}
}
}
public TrainingSequence <float> GetNextSamples(int count)
{
var tuples = Enumerable.Range(0, count)
.Select(x =>
{
int a, b;
if (_rand)
{
a = SafeRandom.Generator.Next(2);
b = SafeRandom.Generator.Next(2);
}
else
{
a = cnt & 0x01;
b = (cnt & 0x02) >> 1;
}
cnt++;
return(new Tuple <int, int, int>(a, b, a ^ b));
}).ToList();
return(new TrainingSequence <float>(tuples.Select(x => MatrixFactory.Create <float>(2, 1, x.Item1, x.Item2)).ToList(), tuples.Select(x => MatrixFactory.Create <float>(1, 1, x.Item3)).ToList()));
}
private void AddVertex(IVertexDest <T> vc, T x, T y)
{
vc.Add(MatrixFactory <T> .CreateVector2D(x, y));
}
public void Ctor_CreateInstance_IsNotNull()
{
var obj = new MatrixFactory();
Assert.That(obj, Is.Not.Null);
}
public Sample <T> GetNextSample()
{
return(new Sample <T>(MatrixFactory.RandomMatrix <T>(_inputSize, _batchSize, 1.0f), MatrixFactory.RandomMatrix <T>(_outputSize, _batchSize, 1.0f)));
}
public static void ProceedDailyTasks()
{
log = new StringBuilder();
var Entry = new CronEntry();
Entry.Date = DateTime.Now;
try
{
Log("Starting CRON procedure");
//Make sure it runs only once
if (CanRun())
{
AppSettings.IsOffline = true;
AppSettings.Misc.LastCRONRun = DateTime.Now;
AppSettings.Misc.Save();
stime = DateTime.Now;
AntiCheatSystem.CRON();
Log("OK [1] AntiCheatSystem. Elapsed time: " + GetTimeString(stime));
RentReferralsSystem.CRON();
Log("OK [2] RentedReferralsSystem. Elapsed time: " + GetTimeString(stime));
StatisticsManager.CRON();
Log("OK [3a] StatisticsManager. Elapsed time: " + GetTimeString(stime));
//MUST BE RUN BEFORE MEMBERMANAGER.CRON() !!!
CustomFeaturesManager.CRON();
Log("OK [3b] CustomFeaturesManager. Elapsed time: " + GetTimeString(stime));
MemberManager.CRON();
Log("OK [4] Member. Elapsed time: " + GetTimeString(stime));
SyncedNetworkFactory.SynchronizeAll();
Log("OK [5] CPA Offers. Elapsed time: " + GetTimeString(stime));
AppSettings.Payments.CRON();
Log("OK [6] Payments. Elapsed time: " + GetTimeString(stime));
ShoutboxManager.CRON();
Log("OK [7] Shoutbox. Elapsed time: " + GetTimeString(stime));
CLPManager.CRON();
Log("OK [8] CLPManager. Elapsed time: " + GetTimeString(stime));
BannerAuctionManager.CRON();
Log("OK [10] BannerAuctionManager. Elapsed time: " + GetTimeString(stime));
PointsLockingManager.CRON();
Log("OK [11] PointsLockingManager. Elapsed time: " + GetTimeString(stime));
DBArchiver.CRON();
Log("OK [12] DBArchiver. Elapsed time: " + GetTimeString(stime));
RevenueSharesDistributionManager.CRON();
Log("OK [13] RevenueSharesDistributionManager. Elapsed time: " + GetTimeString(stime));
CreditLineManager.CRON();
Log("OK [14] CreditLineManager. Elapsed time: " + GetTimeString(stime));
PoolRotatorManager.CRON();
Log("OK [15] PoolRotatorManager. Elapsed time: " + GetTimeString(stime));
JackpotManager.CRON();
Log("OK [16] JackpotManager. Elapsed time: " + GetTimeString(stime));
TrafficExchangeManager.CRON();
Log("OK [17] TrafficExchangeManager. Elapsed time: " + GetTimeString(stime));
DailyPoolManager.CRON();
Log("OK [18] DailyPoolManager. Elapsed time: " + GetTimeString(stime));
//Matrix
MatrixBase matrix = MatrixFactory.GetMatrix();
if (matrix != null)
{
matrix.CRON();
}
Log("OK [19] MatrixBase. Elapsed time: " + GetTimeString(stime));
ApiAccessToken.CRON();
Log("OK [20] ApiAccessToken. Elapsed time: " + GetTimeString(stime));
InvestmentPlatformManager.CRON();
Log("OK [21] InvestmentPlatformManager. Elapsed time: " + GetTimeString(stime));
MarketplaceBalanceLogManager.CRON();
Log("OK [22] MarketplaceBalanceLogManager. Elapsed time: " + GetTimeString(stime));
MiniVideoManager.CRON();
Log("OK [23] MiniVideoManager. Elapsed time: " + GetTimeString(stime));
PaidToPromoteManager.CRON();
Log("OK [24] PaidToPromoteManager. Elapsed time: " + GetTimeString(stime));
RollDiceLotteryManager.CRON();
Log("OK [25] RollDiceLotteryManager. Elapsed time: " + GetTimeString(stime));
WalletManager.CRON();
Log("OK [26] WalletManager. Elapsed time: " + GetTimeString(stime));
NewsManager.CRON();
Log("OK [27] NewsManager. Elapsed time: " + GetTimeString(stime));
Entry.Type = 1;
Entry.Text = "Procedure completed successfully (27/27 100%) after " + GetTimeString(stime);
}
else
{
Entry.Type = 2;
Entry.Text = "Procedure prevented from multiple run";
}
}
catch (Exception ex)
{
ErrorLogger.Log(ex);
Log("Fatal error (exception thrown)..");
Entry.Type = 3;
Entry.Text = "Fatal error during procedure execution. Check logs for more information";
Mailer.SendCRONFailureMessage();
}
finally
{
ErrorLogger.Log(log.ToString(), LogType.CRON);
AppSettings.IsOffline = false;
Entry.Save();
HttpContext.Current.Response.Write(Entry.Text);
}
}
public override void OnDraw()
{
int width = (int)rbuf_window().Width;
int height = (int)rbuf_window().Height;
if (m_num_cb.value().NotEqual(m_slider_value))
{
generate_alpha_mask(width, height);
m_slider_value = m_num_cb.value();
}
g_rasterizer.SetVectorClipBox(0, 0, width, height);
IPixelFormat pf = new FormatRGB(rbuf_window(), new BlenderBGR());
unsafe
{
fixed(byte *pAlphaBuffer = m_alpha_buf)
{
m_alpha_mask_rbuf.attach(pAlphaBuffer, (uint)width, (uint)height, width, 1);
AGG.PixelFormat.AlphaMaskAdaptor pixFormatAlphaMaskAdaptor = new AGG.PixelFormat.AlphaMaskAdaptor(pf, m_alpha_mask);
FormatClippingProxy alphaMaskClippingProxy = new FormatClippingProxy(pixFormatAlphaMaskAdaptor);
FormatClippingProxy clippingProxy = new FormatClippingProxy(pf);
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));
clippingProxy.Clear(new RGBA_Doubles(1, 1, 1));
// draw a background to show how the mask is working better
int RectWidth = 30;
for (int i = 0; i < 40; i++)
{
for (int j = 0; j < 40; j++)
{
if ((i + j) % 2 != 0)
{
VertexSource.RoundedRect <T> rect = new VertexSource.RoundedRect <T>(i * RectWidth, j * RectWidth, (i + 1) * RectWidth, (j + 1) * RectWidth, 0);
rect.NormalizeRadius();
// Drawing as an outline
g_rasterizer.AddPath(rect);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(.9, .9, .9));
}
}
}
//int x, y;
// Render the lion
ConvTransform <T> trans = new ConvTransform <T>(g_path, mtx);
Renderer <T> .RenderSolidAllPaths(alphaMaskClippingProxy, g_rasterizer, g_scanline, trans, g_colors, g_path_idx, g_npaths);
/*
* // Render random Bresenham lines and markers
* agg::renderer_markers<amask_ren_type> m(r);
* for(i = 0; i < 50; i++)
* {
* m.line_color(agg::rgba8(randGenerator.Next() & 0x7F,
* randGenerator.Next() & 0x7F,
* randGenerator.Next() & 0x7F,
* (randGenerator.Next() & 0x7F) + 0x7F));
* m.fill_color(agg::rgba8(randGenerator.Next() & 0x7F,
* randGenerator.Next() & 0x7F,
* randGenerator.Next() & 0x7F,
* (randGenerator.Next() & 0x7F) + 0x7F));
*
* m.line(m.coord(randGenerator.Next() % width), m.coord(randGenerator.Next() % height),
* m.coord(randGenerator.Next() % width), m.coord(randGenerator.Next() % height));
*
* m.marker(randGenerator.Next() % width, randGenerator.Next() % height, randGenerator.Next() % 10 + 5,
* agg::marker_e(randGenerator.Next() % agg::end_of_markers));
* }
*
*
* // Render random anti-aliased lines
* double w = 5.0;
* agg::line_profile_aa profile;
* profile.width(w);
*
* typedef agg::renderer_outline_aa<amask_ren_type> renderer_type;
* renderer_type ren(r, profile);
*
* typedef agg::rasterizer_outline_aa<renderer_type> rasterizer_type;
* rasterizer_type ras(ren);
* ras.round_cap(true);
*
* for(i = 0; i < 50; i++)
* {
* ren.Color = agg::rgba8(randGenerator.Next() & 0x7F,
* randGenerator.Next() & 0x7F,
* randGenerator.Next() & 0x7F,
* //255));
* (randGenerator.Next() & 0x7F) + 0x7F);
* ras.move_to_d(randGenerator.Next() % width, randGenerator.Next() % height);
* ras.line_to_d(randGenerator.Next() % width, randGenerator.Next() % height);
* ras.render(false);
* }
*
*
* // Render random circles with gradient
* typedef agg::gradient_linear_color<color_type> grad_color;
* typedef agg::gradient_circle grad_func;
* typedef agg::span_interpolator_linear<> interpolator_type;
* typedef agg::span_gradient<color_type,
* interpolator_type,
* grad_func,
* grad_color> span_grad_type;
*
* agg::trans_affine grm;
* grad_func grf;
* grad_color grc(agg::rgba8(0,0,0), agg::rgba8(0,0,0));
* agg::ellipse ell;
* agg::span_allocator<color_type> sa;
* interpolator_type inter(grm);
* span_grad_type sg(inter, grf, grc, 0, 10);
* agg::renderer_scanline_aa<amask_ren_type,
* agg::span_allocator<color_type>,
* span_grad_type> rg(r, sa, sg);
* for(i = 0; i < 50; i++)
* {
* x = randGenerator.Next() % width;
* y = randGenerator.Next() % height;
* double r = randGenerator.Next() % 10 + 5;
* grm.reset();
* grm *= agg::trans_affine_scaling(r / 10.0);
* grm *= agg::trans_affine_translation(x, y);
* grm.invert();
* grc.colors(agg::rgba8(255, 255, 255, 0),
* agg::rgba8(randGenerator.Next() & 0x7F,
* randGenerator.Next() & 0x7F,
* randGenerator.Next() & 0x7F,
* 255));
* sg.color_function(grc);
* ell.init(x, y, r, r, 32);
* g_rasterizer.add_path(ell);
* agg::render_scanlines(g_rasterizer, g_scanline, rg);
* }
*/
//m_num_cb.Render(g_rasterizer, g_scanline, clippingProxy);
}
m_alpha_mask_rbuf.dettachBuffer();
}
base.OnDraw();
}
public override void OnDraw()
{
RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>();
ScanlineUnpacked8 sl = new ScanlineUnpacked8();
#if SourceDepth24
FormatRGB pixf = new FormatRGB(rbuf_window(), new BlenderBGR());
#else
FormatRGBA pixf = new FormatRGBA(rbuf_window(), new blender_bgra32());
#endif
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
clippingProxy.Clear(new RGBA_Doubles(0, 0, 0));
m_profile.text_size(8.0);
//m_profile.Render(ras, sl, clippingProxy);
//m_spline_r.Render(ras, sl, clippingProxy);
//m_spline_g.Render(ras, sl, clippingProxy);
//m_spline_b.Render(ras, sl, clippingProxy);
//m_spline_a.Render(ras, sl, clippingProxy);
//m_GradTypeRBox.Render(ras, sl, clippingProxy);
//m_GradWrapRBox.Render(ras, sl, clippingProxy);
// draw a background to show how the alpha is working
int RectWidth = 32;
int xoffset = 238;
int yoffset = 171;
for (int i = 0; i < 7; i++)
{
for (int j = 0; j < 7; j++)
{
if ((i + j) % 2 != 0)
{
VertexSource.RoundedRect <T> rect = new VertexSource.RoundedRect <T>(i * RectWidth + xoffset, j * RectWidth + yoffset,
(i + 1) * RectWidth + xoffset, (j + 1) * RectWidth + yoffset, 2);
rect.NormalizeRadius();
// Drawing as an outline
ras.AddPath(rect);
Renderer <T> .RenderSolid(clippingProxy, ras, sl, new RGBA_Bytes(.9, .9, .9));
}
}
}
double ini_scale = 1.0;
IAffineTransformMatrix <T> mtx1 = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
mtx1.Scale(MatrixFactory <T> .CreateVector2D(ini_scale, ini_scale));
mtx1.Translate(MatrixFactory <T> .CreateVector2D(center_x, center_y));
mtx1.Add(trans_affine_resizing());
VertexSource.Ellipse <T> e1 = new AGG.VertexSource.Ellipse <T>();
e1.Init(0.0, 0.0, 110.0, 110.0, 64);
IAffineTransformMatrix <T> mtx_g1 = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
mtx_g1.Scale(MatrixFactory <T> .CreateVector2D(ini_scale, ini_scale));
mtx_g1.Scale(MatrixFactory <T> .CreateVector2D(m_SaveData.m_scale, m_SaveData.m_scale));
mtx_g1.Scale(MatrixFactory <T> .CreateVector2D(m_scale_x, m_scale_y));
mtx_g1.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), m_SaveData.m_angle.ToDouble());
mtx_g1.Translate(MatrixFactory <T> .CreateVector2D(m_SaveData.m_center_x, m_SaveData.m_center_y));
mtx_g1.Add(trans_affine_resizing());
mtx_g1 = mtx_g1.Inverse;
RGBA_Bytes[] color_profile = new RGBA_Bytes[256]; // color_type is defined in pixel_formats.h
for (int i = 0; i < 256; i++)
{
color_profile[i] = new RGBA_Bytes(m_spline_r.spline()[i].ToInt(),
m_spline_g.spline()[i].ToInt(),
m_spline_b.spline()[i].ToInt(),
m_spline_a.spline()[i].ToInt());
}
ConvTransform <T> t1 = new ConvTransform <T>(e1, mtx1);
IGradient innerGradient = null;
switch (m_GradTypeRBox.cur_item())
{
case 0:
innerGradient = new GradientRadial();
break;
case 1:
innerGradient = new GradientDiamond();
break;
case 2:
innerGradient = new GradientX();
break;
case 3:
innerGradient = new GradientXY();
break;
case 4:
innerGradient = new GradientSqrtXY();
break;
case 5:
innerGradient = new GradientConic();
break;
}
IGradient outerGradient = null;
switch (m_GradWrapRBox.cur_item())
{
case 0:
outerGradient = new GradientReflectAdaptor(innerGradient);
break;
case 1:
outerGradient = new GradientRepeatAdaptor(innerGradient);
break;
case 2:
outerGradient = new GradientClampAdaptor(innerGradient);
break;
}
SpanAllocator span_alloc = new SpanAllocator();
ColorFunctionProfile colors = new ColorFunctionProfile(color_profile, m_profile.gamma());
SpanInterpolatorLinear <T> inter = new SpanInterpolatorLinear <T>(mtx_g1);
SpanGradient <T> span_gen = new SpanGradient <T>(inter, outerGradient, colors, 0, 150);
ras.AddPath(t1);
Renderer <T> .GenerateAndRender(ras, sl, clippingProxy, span_alloc, span_gen);
base.OnDraw();
}
protected virtual void ApplyCyclogenesys(DenseMatrix[] applyDevs, DenseMatrix T0, DenseMatrix P0)
{
DenseMatrix rawP = P0.Clone() as DenseMatrix;
DenseMatrix deltaT = null;
DenseMatrix deltaP = null;
float thickness = 0;
float levelPressure = 0;
switch (_levelType)
{
case LevelType.TopLevel:
deltaT = (Earth.ATM.TopLevel.T - MatrixFactory.Init(-55));
deltaP = (Earth.ATM.TopLevel.P - MatrixFactory.Init(300));
thickness = -4.5f;
levelPressure = LevelPressure.TopLevelPressure;
break;
case LevelType.MidLevel:
deltaT = (Earth.ATM.MidLevel.T - Earth.ATM.TopLevel.T);
deltaP = (Earth.ATM.MidLevel.P - Earth.ATM.TopLevel.P);
thickness = -4f;
levelPressure = LevelPressure.MidLevelPressure;
break;
case LevelType.SeaLevel:
deltaT = (Earth.ATM.SeaLevel.T - Earth.ATM.MidLevel.T);
deltaP = (Earth.ATM.SeaLevel.P - Earth.ATM.MidLevel.P);
thickness = -1.5f;
levelPressure = LevelPressure.SeaLevelPressure;
break;
}
var weakBlock = Earth.ATM.JetLevel.WeakBlockTH;
var strongBlock = Earth.ATM.JetLevel.StrongBlockTH;
var DIV = (10 * Earth.ATM.JetLevel.P.Divergence()).EQ(4);
rawP.Assign((r, c) =>
{
var front = Earth.ATM.Fronts[r, c];
var pJetLevel = Earth.ATM.JetLevel.P[r, c];
var t = T[r, c] + AbsoluteConstants.WaterFreezePoint;
var t0 = T0[r, c] + AbsoluteConstants.WaterFreezePoint;
var p0 = P0[r, c];
var lapseRate = Math.Abs(deltaT[r, c] / thickness);
var unitDp = levelPressure * Math.Abs((t - t0) / AbsoluteConstants.WaterFreezePoint);
var cf = -SimulationParameters.Instance.CyclogeneticFactor;
var acf = SimulationParameters.Instance.AntiCyclogeneticFactor;
var div = DIV[r, c];
const float strong = 2.5f;
const float weak = 0.5f;
const float pseudoStationary = 0.1f;
//bool stable = ((lapseRate > SimulationParameters.Instance.HumidLapseRate) || (pJetLevel > strongBlock));
//bool unstable = ((lapseRate < SimulationParameters.Instance.HumidLapseRate) || (pJetLevel < weakBlock));
//bool stable = ((pJetLevel >= strongBlock));
//bool unstable = ((pJetLevel <= weakBlock));
bool stable = ((div <= -1));
bool unstable = ((div >= 1));
float actualDp = 0;
if (front < 0)
{
if (stable)
{
actualDp = cf * pseudoStationary * unitDp;
}
else if (unstable)
{
actualDp = cf * strong * unitDp;
}
else
{
actualDp = cf * weak * unitDp;
}
}
else if (front > 0)
{
actualDp = acf * pseudoStationary * unitDp;
}
else
{
if (stable)
{
actualDp = acf * strong * unitDp;
}
else if (unstable)
{
actualDp = acf * pseudoStationary * unitDp;
}
else
{
actualDp = acf * weak * unitDp;
}
}
var p = p0 + Earth.SnapshotDivFactor * actualDp;
if (p < PressureExtremes[0])
{
p = PressureExtremes[0];
}
if (p > PressureExtremes[1])
{
p = PressureExtremes[1];
}
return(p);
});
var pNorth = rawP.RegionSubMatrix(-180, 179, 0, 89);
var pSouth = rawP.RegionSubMatrix(-180, 179, -89, -1);
var projPNorth = pNorth.Divide(pNorth.Mean()).Multiply(levelPressure) as DenseMatrix;
var projPSouth = pSouth.Divide(pSouth.Mean()).Multiply(levelPressure) as DenseMatrix;
var projP = MatrixFactory.Init();
projP.SetSubMatrix(0, pNorth.RowCount, 0, pNorth.ColumnCount, projPNorth);
projP.SetSubMatrix(pNorth.RowCount, pSouth.RowCount, 0, pSouth.ColumnCount, projPSouth);
P = projP.EQ(4).ApplyDeviations(applyDevs, null).EQ(4);
}
public SurfaceLevel(EarthModel earth, bool loadFromStateFiles, float defaultValue = 0)
{
this.Earth = earth;
InitGeographicalParams();
if (loadFromStateFiles == false)
{
if (defaultValue == 0)
{
// ------------
// Soil temperature where applicable
string filePath = Path.Combine(SimulationData.WorkFolder, "SOIL.thd");
if (File.Exists(filePath))
{
var tl = FileSupport.LoadMatrixFromFile(filePath);
TL.Assign((r, c) =>
{
if (WL[r, c] == 0)
{
return(tl[r, c]);
}
return(0);
});
}
// ------------
// Sea temperature where applicable
filePath = Path.Combine(SimulationData.WorkFolder, "SST.thd");
if (File.Exists(filePath))
{
var tw = FileSupport.LoadMatrixFromFile(filePath);
TW.Assign((r, c) =>
{
if (WL[r, c] != 0)
{
return(tw[r, c]);
}
return(0);
});
}
// Combined surface temperature
TS.Assign((r, c) =>
{
if (WL[r, c] != 0)
{
return(TW[r, c]);
}
return(TL[r, c]);
});
// ------------
// Snow cover
filePath = Path.Combine(SimulationData.WorkFolder, "SNOW.thd");
if (File.Exists(filePath))
{
this.SNOW = FileSupport.LoadMatrixFromFile(filePath);
}
}
else
{
TE = MatrixFactory.Init(defaultValue);
TW = MatrixFactory.Init(defaultValue);
TL = MatrixFactory.Init(defaultValue);
TS = MatrixFactory.Init(defaultValue);
SNOW = MatrixFactory.Init(defaultValue);
RAIN = MatrixFactory.Init(defaultValue);
BLIZZARD = MatrixFactory.Init(defaultValue);
ALBEDO = MatrixFactory.Init(defaultValue);
Precip = MatrixFactory.Init(defaultValue);
TLow = MatrixFactory.Init(defaultValue);
THigh = MatrixFactory.Init(defaultValue);
LIDX = MatrixFactory.Init(defaultValue);
FOG = MatrixFactory.Init(defaultValue);
TNormLow = MatrixFactory.Init(defaultValue);
TNormHigh = MatrixFactory.Init(defaultValue);
}
}
else
{
TE = FileSupport.Load(Earth.UTC.Title, "T_TE_MAP");
TW = FileSupport.Load(Earth.UTC.Title, "T_TW_MAP");
TL = FileSupport.Load(Earth.UTC.Title, "T_TL_MAP");
TS = FileSupport.Load(Earth.UTC.Title, "T_TS_MAP");
SNOW = FileSupport.Load(Earth.UTC.Title, "N_00_MAP");
RAIN = FileSupport.Load(Earth.UTC.Title, "R_00_MAP");
BLIZZARD = FileSupport.Load(Earth.UTC.Title, "B_00_MAP");
ALBEDO = FileSupport.Load(Earth.UTC.Title, "A_00_MAP");
Precip = FileSupport.Load(Earth.UTC.Title, "C_00_MAP");
TLow = FileSupport.Load(Earth.UTC.Title, "T_SL_MAP");
THigh = FileSupport.Load(Earth.UTC.Title, "T_SH_MAP");
LIDX = FileSupport.Load(Earth.UTC.Title, "L_00_MAP");
FOG = FileSupport.Load(Earth.UTC.Title, "F_SI_MAP");
TNormLow = FileSupport.Load(Earth.UTC.Title, "T_NL_MAP");
TNormHigh = FileSupport.Load(Earth.UTC.Title, "T_NH_MAP");
}
}
public void CalculateTotalPrecipitation()
{
var GP = Earth.ATM.MidLevel.P.Gradient2().Rescale(new float[] { 0, 100 });
var GT = Earth.ATM.MidLevel.T.Gradient2().Rescale(new float[] { 0, 100 });
var TS = Earth.SFC.TS;
var TE = Earth.SFC.TE;
DenseMatrix WIND = MatrixFactory.Init();
if (Earth.ATM.SeaLevel.P != null)
{
WIND = Earth.ATM.SeaLevel.P.Gradient2();
}
var HMid = Earth.ATM.MidLevel.H;
var HSea = Earth.ATM.SeaLevel.H;
if (HSea == null)
{
HSea = HMid;
}
var eqFronts = Earth.ATM.Fronts;//.EQ();
// Calculate convective precipitation (thunderstorms)
CalculateInstabilityIndex(eqFronts);
var FP = Earth.ATM.JetLevel.FP;
Precip.Assign((r, c) =>
{
var hgt = Earth.SFC.Height[r, c];
float h = 0;
var hTop = Earth.ATM.TopLevel.H[r, c];
var hMid = Earth.ATM.MidLevel.H[r, c];
var hSea = Earth.ATM.SeaLevel.H[r, c];
if (hgt > SimConstants.LevelHeights[LevelType.TopLevel])
{
h = 0.5f * hTop;
}
else if (hgt > SimConstants.LevelHeights[LevelType.MidLevel])
{
h = 0.5f * (hTop + hMid);
}
else
{
h = 0.5f * (hSea + hMid);
}
var lidx = LIDX[r, c];
var gp = GP[r, c];
var gt = GT[r, c];
var fp = FP[r, c];
// Baric gradient precipitation
var pRate = 0.5f * Math.Abs(gp);
// Frontal precipitation
var f = eqFronts[r, c];
var dx = (f > 0) ? 0.75f : 1.5f;
var fRate = dx * 20 * Math.Abs(f);
// Orographic precipitation
var oRate = 0.3f * ((hgt >= 900) ? h : 0);
// Convective precipitation
var cRate = 0f;
if (lidx < 0)
{
var lidxRate = Math.Abs(lidx);
var mul = 1;
if (lidx > 3)
{
mul = 2;
}
if (lidx > 5)
{
mul = 3;
}
if (lidx > 7)
{
mul = 4;
}
if (lidx > 9)
{
mul = 5;
}
cRate = fp * mul * Math.Abs(lidxRate);
}
var totalRate = (pRate + fRate + oRate + cRate) * h / 100;
return(Math.Min(300, totalRate));
});
DenseMatrix SolidPrecip = MatrixFactory.Init();
for (int r = 0; r < SolidPrecip.RowCount; r++)
{
for (int c = 0; c < SolidPrecip.ColumnCount; c++)
{
var wl = WL[r, c];
var ts = TS[r, c];
var te = TE[r, c];
var cl = Precip[r, c];
var t01 = Earth.ATM.MidLevel.T[r, c];
var totalRain = RAIN[r, c];
var totalSnow = SNOW[r, c];
var fogMeltFactor = Math.Min(1, 1 - FOG[r, c] / 100);
const float precipClThreshold = 10f;
if (te >= -10f || cl <= precipClThreshold)
{
if (te >= 0)
{
// Accumulated soil moisture evaporation
totalRain -= 0.5f * te * Earth.SnapshotLength;
if (totalRain < 0)
{
totalRain = 0;
}
// Old snow cover is melting and transforming into water
// OBS: Snow melts faster when we have fog
var meltedSnow = Math.Min(totalSnow, 0.2f * (1 + fogMeltFactor) * te * Earth.SnapshotLength);
totalSnow -= meltedSnow;
if (totalSnow < 0)
{
totalSnow = 0;
}
// Consider melted snow as rain because it contributes to the total soil moisture
totalRain += meltedSnow;
}
else
{
// Old snow cover is slowly compacting due to daytime melt / night time freeze
totalSnow -= 0.025f * (1 + fogMeltFactor) * Earth.SnapshotLength;
if (totalSnow < 0)
{
totalSnow = 0;
}
}
}
DaysSinceLastRainFall[r, c] = (DaysSinceLastRainFall[r, c] + Earth.SnapshotDivFactor);
DaysSinceLastSnowFall[r, c] = (DaysSinceLastSnowFall[r, c] + Earth.SnapshotDivFactor);
float actualPrecipRate = (cl - precipClThreshold);
if (actualPrecipRate > 0)
{
var unitPrecipFall = actualPrecipRate * Earth.SnapshotDivFactor;
PrecipTypeComputer <float> .Compute(
// Actual temperatures
te, ts, t01,
// Boundary temperatures as read from simulation parameters
SimulationParameters.Instance,
// Computed precip type: snow
() =>
{
totalSnow += 0.3f * unitPrecipFall;
SolidPrecip[r, c] = 1;
DaysSinceLastSnowFall[r, c] = 0;
return(0);
},
// Computed precip type: rain
() =>
{
totalRain += unitPrecipFall;
DaysSinceLastRainFall[r, c] = 0;
return(0);
},
// Computed precip type: freezing rain
() =>
{
totalSnow += 0.1f * unitPrecipFall;
totalRain += 0.9f * unitPrecipFall;
SolidPrecip[r, c] = 1;
DaysSinceLastSnowFall[r, c] = 0;
return(0);
},
// Computed precip type: sleet
() =>
{
totalSnow += 0.2f * unitPrecipFall;
totalRain += 0.8f * unitPrecipFall;
SolidPrecip[r, c] = 1;
DaysSinceLastSnowFall[r, c] = 0;
return(0);
}
);
}
if (totalSnow < 0 ||
// Snow does not accumulate on a water surface if water is not frozen
(wl != 0 && ts > 0))
{
totalSnow = 0;
}
if (totalRain < 0 ||
// Rain water does not accumulate on a water surface
wl != 0)
{
totalRain = 0;
}
RAIN[r, c] = totalRain;
SNOW[r, c] = totalSnow;
}
}
;
Earth.SFC.BLIZZARD.Assign((r, c) =>
{
var wind = WIND[r, c];
var cl = Precip[r, c] / 20f;
bool solidPrecip = (SolidPrecip[r, c] != 0);
if (solidPrecip)
{
return(Math.Abs(cl * wind));
}
return(0);
});
Earth.SFC.ALBEDO.Assign((r, c) =>
{
var wl = WL[r, c];
var defAlbedo = DEF_ALBEDO[r, c];
//if (wl == 0)
{
var snowAlbedo = 0f;
var rainAlbedo = 0f;
if (SNOW[r, c] > 3f)
{
snowAlbedo = SNOW[r, c] + 20f * Math.Max(0, 5 - DaysSinceLastSnowFall[r, c]);
}
if (RAIN[r, c] >= 10f)
{
rainAlbedo = 0.5f * RAIN[r, c] + 10f * Math.Max(0, 3 - DaysSinceLastRainFall[r, c]);
}
var total = Math.Min(100f, defAlbedo + snowAlbedo + rainAlbedo);
return(total);
//return Math.Max(total, defAlbedo);
}
//return defAlbedo;
});
}
public Entity(T radius)
{
m_Radius = radius;
m_Velocity = MatrixFactory <T> .CreateVector2D(60, 120);
}
public void Register_RegisterFunc_DoewNotThrow()
{
var fact = new MatrixFactory();
fact.Register <double, DoubleField, Matrix <double, DoubleField> >((row, col) => new Matrix <double, DoubleField>(row, col));
}
/// <summary>The set reinforcement bars level.</summary>
/// <param name="rebar">The rebar.</param>
/// <returns>The System.String.</returns>
public string SetRebarsLevel(Reinforcement rebar)
{
var result = string.Empty;
var rebarGeometries = rebar.GetRebarGeometries(false);
var fatherPart = rebar.Father as Part;
if (fatherPart != null)
{
var slabsSolid = fatherPart.GetSolid();
var maxDepth = Math.Abs(slabsSolid.MaximumPoint.Z);
var minDepth = Math.Abs(slabsSolid.MinimumPoint.Z);
// Is it a slab or wall
if (!this.PartIsSlab(rebar.Father))
{
// Walls reinforcement bars geometry have to be rotated and shifted to run
// same methods as for slabs.
var csys1 = fatherPart.GetCoordinateSystem();
var rotMat = MatrixFactory.Rotate(Math.PI / 2, csys1.AxisX);
maxDepth = this.RotateSlabPoint(slabsSolid.MaximumPoint, rotMat, csys1.Origin);
minDepth = this.RotateSlabPoint(slabsSolid.MinimumPoint, rotMat, csys1.Origin);
this.RotateRebarsGeometries(ref rebarGeometries, rotMat, csys1.Origin);
if (maxDepth > 0 && minDepth < 0)
{
this.ShiftRebars(ref rebarGeometries, ref maxDepth, ref minDepth);
}
}
else
{
this.ShiftRebars(ref rebarGeometries, ref maxDepth, ref minDepth);
}
var confine = maxDepth > Epsilon ? maxDepth : minDepth;
var rebarsLevel = Math.Abs(GetRebarsPredominantLevel(rebarGeometries));
if (this.PartIsSlab(rebar.Father))
{
if (rebarsLevel < confine / 2)
{
result = this.PrefixTop + Math.Floor(rebarsLevel);
}
else
{
result = this.PrefixBot + Math.Floor(rebarsLevel);
}
}
else
{
if (rebarsLevel < confine / 2)
{
result = this.PrefixFront + Math.Floor(rebarsLevel);
}
else
{
result = this.PrefixBack + Math.Floor(rebarsLevel);
}
}
}
return(result);
}
public TrainingSequence <T> GetNextSamples(int count)
{
return(new TrainingSequence <T>(
Enumerable.Range(0, count).Select(x => MatrixFactory.RandomMatrix <T>(_inputSize, _batchSize, 1.0f)).ToList(),
Enumerable.Range(0, count).Select(x => MatrixFactory.RandomMatrix <T>(_outputSize, _batchSize, 1.0f)).ToList()));
}
public override void OnDraw()
{
//typedef agg::renderer_base<agg::pixfmt_bgr24> ren_base;
FormatRGB pixf = new FormatRGB(rbuf_window(), new BlenderBGR());
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
clippingProxy.Clear(new RGBA_Doubles(1, 1, 1));
m_ras.SetVectorClipBox(0, 0, width().ToDouble(), height().ToDouble());
IAffineTransformMatrix <T> move = MatrixFactory <T> .NewTranslation(10, 10);
Perspective <T> shadow_persp = new Perspective <T>(m_shape_bounds.x1, m_shape_bounds.y1,
m_shape_bounds.x2, m_shape_bounds.y2,
m_shadow_ctrl.polygon());
IVertexSource <T> shadow_trans;
if (m_FlattenCurves.status())
{
shadow_trans = new ConvTransform <T>(m_shape, shadow_persp);
}
else
{
shadow_trans = new ConvTransform <T>(m_path, shadow_persp);
// this will make it very smooth after the Transform
//shadow_trans = new conv_curve(shadow_trans);
}
// Render shadow
m_ras.AddPath(shadow_trans);
Renderer <T> .RenderSolid(clippingProxy, m_ras, m_sl, new RGBA_Doubles(0.2, 0.3, 0).GetAsRGBA_Bytes());
// Calculate the bounding box and extend it by the blur radius
RectDouble <T> bbox = new RectDouble <T>();
BoundingRect <T> .BoundingRectSingle(shadow_trans, 0, ref bbox);
bbox.x1.SubtractEquals(m_radius.value());
bbox.y1.SubtractEquals(m_radius.value());
bbox.x2.AddEquals(m_radius.value());
bbox.y2.AddEquals(m_radius.value());
if (m_method.cur_item() == 1)
{
// The recursive blur method represents the true Gaussian Blur,
// with theoretically infinite kernel. The restricted window size
// results in extra influence of edge pixels. It's impossible to
// solve correctly, but extending the right and top areas to another
// radius Value produces fair result.
//------------------
bbox.x2.AddEquals(m_radius.value());
bbox.y2.AddEquals(m_radius.value());
}
start_timer();
if (m_method.cur_item() != 2)
{
// Create a new pixel renderer and Attach it to the main one as a child image.
// It returns true if the attachment succeeded. It fails if the rectangle
// (bbox) is fully clipped.
//------------------
FormatRGB pixf2 = new FormatRGB(m_rbuf2, new BlenderBGR());
if (pixf2.Attach(pixf, (int)bbox.x1.ToInt(), (int)bbox.y1.ToInt(), (int)bbox.x2.ToInt(), (int)bbox.y2.ToInt()))
{
// Blur it
if (m_method.cur_item() == 0)
{
// More general method, but 30-40% slower.
//------------------
//m_stack_blur.blur(pixf2, agg::uround(m_radius.Value()));
// Faster, but bore specific.
// Works only for 8 bits per channel and only with radii <= 254.
//------------------
// agg::stack_blur_rgb24(pixf2, agg::uround(m_radius.Value()),
// agg::uround(m_radius.Value()));
}
else
{
// True Gaussian Blur, 3-5 times slower than Stack Blur,
// but still constant time of radius. Very sensitive
// to precision, doubles are must here.
//------------------
m_recursive_blur.Blur(pixf2, m_radius.value().ToDouble());
}
}
}
else
{
/*
* // Blur separate channels
* //------------------
* if(m_channel_r.status())
* {
* typedef agg::pixfmt_alpha_blend_gray<
* agg::blender_gray8,
* agg::rendering_buffer,
* 3, 2> pixfmt_gray8r;
*
* pixfmt_gray8r pixf2r(m_rbuf2);
* if(pixf2r.Attach(pixf, int(bbox.x1), int(bbox.y1), int(bbox.x2), int(bbox.y2)))
* {
* agg::stack_blur_gray8(pixf2r, agg::uround(m_radius.Value()),
* agg::uround(m_radius.Value()));
* }
* }
*
* if(m_channel_g.status())
* {
* typedef agg::pixfmt_alpha_blend_gray<
* agg::blender_gray8,
* agg::rendering_buffer,
* 3, 1> pixfmt_gray8g;
*
* pixfmt_gray8g pixf2g(m_rbuf2);
* if(pixf2g.Attach(pixf, int(bbox.x1), int(bbox.y1), int(bbox.x2), int(bbox.y2)))
* {
* agg::stack_blur_gray8(pixf2g, agg::uround(m_radius.Value()),
* agg::uround(m_radius.Value()));
* }
* }
*
* if(m_channel_b.status())
* {
* typedef agg::pixfmt_alpha_blend_gray<
* agg::blender_gray8,
* agg::rendering_buffer,
* 3, 0> pixfmt_gray8b;
*
* pixfmt_gray8b pixf2b(m_rbuf2);
* if(pixf2b.Attach(pixf, int(bbox.x1), int(bbox.y1), int(bbox.x2), int(bbox.y2)))
* {
* agg::stack_blur_gray8(pixf2b, agg::uround(m_radius.Value()),
* agg::uround(m_radius.Value()));
* }
* }
*/
}
double tm = elapsed_time();
//m_shadow_ctrl.Render(m_ras, m_sl, clippingProxy);
// Render the shape itself
//------------------
if (m_FlattenCurves.status())
{
m_ras.AddPath(m_shape);
}
else
{
m_ras.AddPath(m_path);
}
Renderer <T> .RenderSolid(clippingProxy, m_ras, m_sl, new RGBA_Doubles(0.6, 0.9, 0.7, 0.8).GetAsRGBA_Bytes());
GsvText <T> t = new GsvText <T>();
t.SetFontSize(10.0);
ConvStroke <T> st = new ConvStroke <T>(t);
st.Width = M.New <T>(1.5);
string buf;
buf = string.Format("{0:F2} ms", tm);
t.StartPoint(140.0, 30.0);
t.Text = buf;
m_ras.AddPath(st);
Renderer <T> .RenderSolid(clippingProxy, m_ras, m_sl, new RGBA_Doubles(0, 0, 0).GetAsRGBA_Bytes());
//m_method.Render(m_ras, m_sl, clippingProxy);
//m_radius.Render(m_ras, m_sl, clippingProxy);
//m_channel_r.Render(m_ras, m_sl, clippingProxy);
//m_channel_g.Render(m_ras, m_sl, clippingProxy);
//m_channel_b.Render(m_ras, m_sl, clippingProxy);
//m_FlattenCurves.Render(m_ras, m_sl, clippingProxy);
base.OnDraw();
}
public void Respawn()
{
Random rand = new Random();
Position = MatrixFactory <T> .CreateVector2D(rand.NextDouble() *GameWidth, rand.NextDouble() *GameHeight);
}
public static Matrix MatrixToLocal(this CoordinateSystem cs)
{
return(MatrixFactory.ToCoordinateSystem(cs));
}
