예제 #1
0
 /// <summary>
 /// Converts the matrix.
 /// </summary>
 /// <param name="MediaMatrix">The media matrix.</param>
 /// <returns></returns>
 public static dm ConvertMatrix(mm MediaMatrix)
 {
     var ret = new dm((float) MediaMatrix.M11, (float) MediaMatrix.M12, (float) MediaMatrix.M21,
         (float) MediaMatrix.M22, (float) MediaMatrix.OffsetX,
         (float) MediaMatrix.OffsetY);
     return ret;
 }
예제 #2
0
 public void DoPaintRemote(PaintEventArgs e)
 {
     var matrix = new System.Drawing.Drawing2D.Matrix();
     matrix.Translate(this.Left, this.Top);
     e.Graphics.Transform = matrix;
     OnPaint(e);
 }
예제 #3
0
파일: D2dUtil.cs 프로젝트: Joxx0r/ATF
        /// <summary>
        /// Draws grid lines corresponding to a vertical scale</summary>
        /// <param name="g">The Direct2D graphics object</param>
        /// <param name="transform">Graph (world) to window's client (screen) transform</param>
        /// <param name="graphRect">Graph rectangle</param>
        /// <param name="majorSpacing">Scale's major spacing</param>
        /// <param name="lineBrush">Grid line brush</param>
        public static void DrawVerticalScaleGrid(
            this D2dGraphics g,
            Matrix transform,
            RectangleF graphRect,
            int majorSpacing,
            D2dBrush lineBrush)
        {
            double xScale = transform.Elements[0];
            RectangleF clientRect = Transform(transform, graphRect);

            double min = Math.Min(graphRect.Left, graphRect.Right);
            double max = Math.Max(graphRect.Left, graphRect.Right);
            double tickAnchor = CalculateTickAnchor(min, max);
            double step = CalculateStep(min, max, Math.Abs(clientRect.Right - clientRect.Left), majorSpacing, 0.0);
            if (step > 0)
            {
                double offset = tickAnchor - min;
                offset = offset - MathUtil.Remainder(offset, step) + step;
                for (double x = tickAnchor - offset; x <= max; x += step)
                {
                    double cx = (x - graphRect.Left) * xScale + clientRect.Left;
                    g.DrawLine((float)cx, clientRect.Top, (float)cx, clientRect.Bottom, lineBrush);
                }
            }
        }
예제 #4
0
		/// <summary>
		/// Cloning constructor.
		/// </summary>
		protected SpatialTransform(SpatialTransform source, ICloningContext context)
		{
			context.CloneFields(source, this);

			if (source._cumulativeTransform != null)
				_cumulativeTransform = source._cumulativeTransform.Clone();

			if (source._transform != null)
				_transform = source._transform.Clone();
		}
예제 #5
0
        /// <summary>
        /// Draw all areas of the selected quest and highlight the selected area.
        /// </summary>
        private void Area_Paint(object sender, PaintEventArgs e)
        {
            e.Graphics.Clear(Area.BackColor);

            Matrix transformMatrix = new Matrix();
            transformMatrix.Rotate(90);
            transformMatrix.Multiply(new Matrix(-1, 0, 0, 1, 0, 0)); // Flip x-axis

            WoWQuestStep[] steps = ((QuestDisplayData)bsQuests.Current).Steps;

            float maxX = steps.Max(step => step.AreaPoints.Max(ap => ap.X));
            float maxY = steps.Max(step => step.AreaPoints.Max(ap => ap.Y));

            transformMatrix.Translate(-maxX - 5, -maxY - 5);

            e.Graphics.Transform = transformMatrix;

            // Draw all areas
            foreach (WoWQuestStep step in steps)
            {
                PointF[] drawPoints = ConvertToDrawingPoints(step.AreaPoints);
                if (drawPoints.Length < 3)
                {
                    foreach (PointF point in drawPoints)
                    {
                        // Draw a point 5x5 pixels
                        e.Graphics.FillEllipse(AREA_FILL, point.X - 2, point.Y - 2, 5F, 5F);
                        e.Graphics.DrawEllipse(AREA_BORDER, point.X - 2, point.Y - 2, 5F, 5F);
                    }
                }
                else
                {
                    e.Graphics.FillPolygon(AREA_FILL, drawPoints);
                    e.Graphics.DrawPolygon(AREA_BORDER, drawPoints);
                }
            }

            // Highlight selected area
            if (SelectedAreaPoints != null)
            {
                if (SelectedAreaPoints.Length < 3)
                {
                    foreach (PointF point in SelectedAreaPoints)
                    {
                        e.Graphics.FillEllipse(AREA_HIGHLIGHT, point.X - 2, point.Y - 2, 5F, 5F);
                        e.Graphics.DrawEllipse(AREA_BORDER, point.X - 2, point.Y - 2, 5F, 5F);
                    }
                }
                else
                {
                    e.Graphics.FillPolygon(AREA_HIGHLIGHT, this.SelectedAreaPoints);
                    e.Graphics.DrawPolygon(AREA_BORDER, this.SelectedAreaPoints);
                }
            }
        }
예제 #6
0
        public static SharpMap.Map InitializeMap(int angle, string[] filenames)
        {
            var map = new SharpMap.Map();
            for (int i = 0; i < filenames.Length; i++)
                map.Layers.Add(new SharpMap.Layers.GdalRasterLayer(System.IO.Path.GetFileName(filenames[i]), filenames[i]));

            System.Drawing.Drawing2D.Matrix mat = new System.Drawing.Drawing2D.Matrix();
            mat.RotateAt(angle, map.WorldToImage(map.Center));
            map.MapTransform = mat;
            map.ZoomToExtents();
            return map;
        }
예제 #7
0
		/// <summary>
		/// Initializes a new map
		/// </summary>
		/// <param name="size">Size of map in pixels</param>
		public Map(System.Drawing.Size size)
		{
			this.Size = size;
			this.Layers = new List<SharpMap.Layers.ILayer>();
			this.BackColor = System.Drawing.Color.Transparent;
			this._MaximumZoom = double.MaxValue;
			this._MinimumZoom = 0;
			_MapTransform = new System.Drawing.Drawing2D.Matrix();
			MapTransformInverted = new System.Drawing.Drawing2D.Matrix();
			_Center = new SharpMap.Geometries.Point(0, 0);
			_Zoom = 1;
			_PixelAspectRatio = 1.0;
		}		
예제 #8
0
파일: Map.cs 프로젝트: lishxi/_SharpMap
		/// <summary>
		/// Initializes a new map
		/// </summary>
		/// <param name="size">Size of map in pixels</param>
		public Map(System.Drawing.Size size)
		{
			this.Size = size;
            this.Layers = new SharpMap.Layers.LayerCollection();
			this.BackColor = System.Drawing.Color.Transparent;
			this._MaximumZoom = double.MaxValue;
			this._MinimumZoom = 0;
			_MapTransform = new System.Drawing.Drawing2D.Matrix();
			MapTransformInverted = new System.Drawing.Drawing2D.Matrix();
			_Center = SharpMap.Converters.Geometries.GeometryFactory.CreateCoordinate(0, 0);
			_Zoom = 1;
			_PixelAspectRatio = 1.0;
		}		
예제 #9
0
        internal override void Save(FlowChartModel model)
        {
            float ZoomFactor = 4.0f;

            using (Bitmap bmp = new Bitmap((int)(601*ZoomFactor), (int)(851*ZoomFactor)))
            {
                using (Graphics g = Graphics.FromImage(bmp))
                {
                    System.Drawing.Drawing2D.Matrix mx = new System.Drawing.Drawing2D.Matrix(ZoomFactor, 0, 0, ZoomFactor, 0, 0);                    
                    g.Transform = mx;

                    g.PageUnit = GraphicsUnit.Pixel;
                    g.Clear(Color.White);
                    g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                    g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
                    g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.High;
                    
                    model.Items.ForEach(x =>
                    {
                        x.View.Draw(g);
                    });

                    g.Save();

                    ImageFormat fm = ImageFormat.Bmp;
                    if (Path.GetExtension(fileName).ToLower() == ".png")
                    {
                        fm = System.Drawing.Imaging.ImageFormat.Png;
                    }
                    else if (Path.GetExtension(fileName).ToLower() == ".jpg")
                    {
                        fm = System.Drawing.Imaging.ImageFormat.Jpeg;
                    }
                    else if (Path.GetExtension(fileName).ToLower() == ".jpeg")
                    {
                        fm = System.Drawing.Imaging.ImageFormat.Jpeg;
                    }
                    else if (Path.GetExtension(fileName).ToLower() == ".gif")
                    {
                        fm = System.Drawing.Imaging.ImageFormat.Gif;
                    }
                    else if (Path.GetExtension(fileName).ToLower() == ".tiff")
                    {
                        fm = System.Drawing.Imaging.ImageFormat.Tiff;
                    }
                    bmp.Save(fileName, fm);
                }
            }
        }
        protected override bool InitializeTransformMatrix()
        {
            if (this.CurveList == null)
             {
            this.IsInitialized = false;
            InvalidSerieException e = new InvalidSerieException("No data to display...");
            StockLog.Write(e);
            throw e;
             }
             if (this.GraphRectangle.Height > 0)
             {
            EventSeries.Clear();

            // Create fake Event Series;
            for (int i = 0; i < 5; i++)
            {
               EventSeries.Add(new BoolSerie(this.EndIndex, "Test" + i, i%2 == 0));
            }

            minValue = 0.0f;
            maxValue = EventSeries.Count + 1;

            if (graphic == null)
            {
               // Initialise graphics
               this.graphic = this.CreateGraphics();
               RectangleF rect = this.graphic.VisibleClipBounds;
               rect.Inflate(new SizeF(-this.XMargin, -this.YMargin));
               this.GraphRectangle = rect;
            }

            float coefX = (this.GraphRectangle.Width * 0.96f) / (EndIndex - StartIndex);
            float coefY = this.GraphRectangle.Height / (maxValue - minValue);

            matrixValueToScreen = new System.Drawing.Drawing2D.Matrix();
            matrixValueToScreen.Translate(this.GraphRectangle.X - (StartIndex - 0.5f) * coefX, maxValue * coefY + this.GraphRectangle.Y);
            matrixValueToScreen.Scale(coefX, -coefY);

            matrixScreenToValue = (System.Drawing.Drawing2D.Matrix)matrixValueToScreen.Clone();
            matrixScreenToValue.Invert();
             }
             else
             {
            this.Deactivate("App too small...", false);
            return false;
             }
             return true;
        }
예제 #11
0
        protected override bool InitializeTransformMatrix()
        {
            if (this.CurveList == null)
             {
            this.IsInitialized = false;
            InvalidSerieException e = new InvalidSerieException("No data to display...");
            StockLog.Write(e);
            throw e;
             }
             if (this.GraphRectangle.Height > 0)
             {
            minValue = float.MaxValue;
            maxValue = float.MinValue;
            this.CurveList.GetMinMax(StartIndex, EndIndex, ref minValue, ref maxValue, this.ScaleInvisible);

            if (minValue == maxValue || float.IsNaN(minValue) || float.IsInfinity(minValue) || float.IsNaN(maxValue) || float.IsInfinity(maxValue))
            {
               this.Deactivate("No volume for this stock", false);
               return false;
            }
            if (graphic == null)
            {
               // Initialise graphics
               this.graphic = this.CreateGraphics();
               RectangleF rect = this.graphic.VisibleClipBounds;
               rect.Inflate(new SizeF(-this.XMargin, -this.YMargin));
               this.GraphRectangle = rect;
            }

            float coefX = (this.GraphRectangle.Width * 0.96f) / (EndIndex - StartIndex);
            float coefY = this.GraphRectangle.Height / (maxValue - minValue);

            matrixValueToScreen = new System.Drawing.Drawing2D.Matrix();
            matrixValueToScreen.Translate(this.GraphRectangle.X - (StartIndex - 0.5f) * coefX, maxValue * coefY + this.GraphRectangle.Y);
            matrixValueToScreen.Scale(coefX, -coefY);

            matrixScreenToValue = (System.Drawing.Drawing2D.Matrix)matrixValueToScreen.Clone();
            matrixScreenToValue.Invert();
             }
             else
             {
            this.Deactivate("App too small...", false);
            return false;
             }
             return true;
        }
예제 #12
0
        protected override bool InitializeTransformMatrix()
        {
            if (float.IsNaN(this.RangeMin) || float.IsNaN(this.RangeMax))
             {
            return base.InitializeTransformMatrix();
             }

             if (this.CurveList == null)
             {
            this.IsInitialized = false;
            InvalidSerieException e = new InvalidSerieException("No data to display...");
            throw e;
             }
             if (this.CurveList.GetNbVisible() == 0)
             {
            this.Deactivate("No data to display...", false);
            return false;
             }
             if (this.StartIndex == this.EndIndex || this.EndIndex > this.dateSerie.Length - 1)
             {
            this.IsInitialized = false;
            InvalidSerieException e = new InvalidSerieException("Invalid input data range...");
            throw e;
             }
             if (this.GraphRectangle.Height > 0)
             {
            float minValue = this.RangeMin, maxValue = this.RangeMax;
            float coefX = (this.GraphRectangle.Width * 0.96f) / (EndIndex - StartIndex);
            float coefY = this.GraphRectangle.Height / (maxValue - minValue);

            matrixValueToScreen = new System.Drawing.Drawing2D.Matrix();
            matrixValueToScreen.Translate(this.GraphRectangle.X - (StartIndex - 0.5f) * coefX, maxValue * coefY + this.GraphRectangle.Y);
            matrixValueToScreen.Scale(coefX, -coefY);

            matrixScreenToValue = (System.Drawing.Drawing2D.Matrix)matrixValueToScreen.Clone();
            matrixScreenToValue.Invert();
            return true;
             }
             return false;
        }
예제 #13
0
        public bool DrawNode(Node node, object graphics)
        {
            Graphics g = (Graphics)graphics;

            var m = g.Transform;
            var saveM = g.Transform.Clone();
            //      g.SetClip(FillTheGraphicsPath(node.GeometryNode.BoundaryCurve));

            // This is supposed to flip the text around its center

            var c = (float)node.GeometryNode.Center.Y;
            using (var m2 = new System.Drawing.Drawing2D.Matrix(1, 0, 0, -1, 0, 2 * c))
            {
                m.Multiply(m2);
            }

            m.Translate(
                (float)node.GeometryNode.Center.X,
                (float)node.GeometryNode.Center.Y);

            g.Transform = m;

            var styleStack = GetStyleStack();
            var painter = new TextViewPainter(
                Layout, g,
                SystemColors.WindowText,
                SystemColors.Window,
                SystemFonts.DefaultFont, styleStack);
            var ptr = new TextPointer { Character = 0, Span = 0, Line = TextModel.StartPosition };
            painter.SetSelection(ptr, ptr);
            painter.PaintGdiPlus();
            g.Transform = saveM;
            g.ResetClip();

            saveM.Dispose();
       //     m.Dispose();
            return true;//returning false would enable the default rendering
        }
예제 #14
0
        bool DrawNode(DrawingNode node, object graphics) {
            Graphics g = (Graphics)graphics;
            Image image = ImageOfNode(node);

            //flip the image around its center
            using (System.Drawing.Drawing2D.Matrix m = g.Transform)
            {
                using (System.Drawing.Drawing2D.Matrix saveM = m.Clone())
                {

                    g.SetClip(FillTheGraphicsPath(node.GeometryNode.BoundaryCurve));
                    using (var m2 = new System.Drawing.Drawing2D.Matrix(1, 0, 0, -1, 0, 2 * (float)node.GeometryNode.Center.Y))
                        m.Multiply(m2);

                    g.Transform = m;
                    g.DrawImage(image, new PointF((float)(node.GeometryNode.Center.X - node.GeometryNode.Width / 2),
                        (float)(node.GeometryNode.Center.Y - node.GeometryNode.Height / 2)));
                    g.Transform = saveM;

                }
            }

            return true;//returning false would enable the default rendering
        }
예제 #15
0
        /// <summary>
        /// Paint the tab
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
        {
            bool Painting = false;

            if (Painting)
            {
                return;
            }
            Painting = true;
            this.SuspendLayout();
            Color RenderBorderColor = new Color();
            Color RenderBottomColor = new Color();
            Color RenderHighColor   = new Color();
            Color RenderLowColor    = new Color();

            System.Drawing.Drawing2D.GraphicsPath GraphicPath = new System.Drawing.Drawing2D.GraphicsPath();

            int w = this.Width;

            CalculateWidth();
            if (w != this.Width)
            {
                GraphicPath.Dispose();
                return;
            }

            if (m_Selected)
            {
                RenderBorderColor = Helper.RenderColors.BorderColor(m_RenderMode, BorderColor);
                RenderHighColor   = Helper.RenderColors.TabBackHighColor(m_RenderMode, BackHighColor);
                RenderLowColor    = Helper.RenderColors.TabBackLowColor(m_RenderMode, BackLowColor);
                RenderBottomColor = Helper.RenderColors.TabBackLowColor(m_RenderMode, BackLowColor);
            }
            else if (m_Hot)
            {
                RenderBorderColor = Helper.RenderColors.BorderColor(m_RenderMode, BorderColor);
                RenderHighColor   = Helper.RenderColors.TabBackHighColor(m_RenderMode, BackHighColor);
                RenderLowColor    = Helper.RenderColors.TabBackLowColor(m_RenderMode, BackLowColor);
                RenderBottomColor = Helper.RenderColors.BorderColor(m_RenderMode, BorderColor);
            }
            else
            {
                RenderBorderColor = Helper.RenderColors.BorderColorDisabled(m_RenderMode, BorderColorDisabled);
                RenderHighColor   = Helper.RenderColors.TabBackHighColorDisabled(m_RenderMode, BackHighColorDisabled);
                RenderLowColor    = Helper.RenderColors.TabBackLowColorDisabled(m_RenderMode, BackLowColorDisabled);
                RenderBottomColor = Helper.RenderColors.BorderColor(m_RenderMode, BorderColor);
            }

            e.Graphics.SmoothingMode = m_SmoothingMode;

            GraphicPath.AddPolygon(GetRegion(Width - 1, Height - 1, System.Convert.ToInt32(this.IsSelected ? Height : Height - 1)));

            // if is bottom mirror the button vertically
            if (m_Alignment == TabControl.TabAlignment.Bottom)
            {
                MirrorPath(GraphicPath);
                Color x = RenderHighColor;
                RenderHighColor = RenderLowColor;
                RenderLowColor  = x;
            }

            // Get the correct region including all the borders
            Region R  = new Region(GraphicPath);
            Region R1 = new Region(GraphicPath);
            Region R2 = new Region(GraphicPath);
            Region R3 = new Region(GraphicPath);

            System.Drawing.Drawing2D.Matrix M1 = new System.Drawing.Drawing2D.Matrix();
            System.Drawing.Drawing2D.Matrix M2 = new System.Drawing.Drawing2D.Matrix();
            System.Drawing.Drawing2D.Matrix M3 = new System.Drawing.Drawing2D.Matrix();
            M1.Translate(0, -0.5F);
            M2.Translate(0, 0.5F);
            M3.Translate(1, 0);
            R1.Transform(M1);
            R2.Transform(M2);
            R3.Transform(M3);
            R.Union(R1);
            R.Union(R2);
            R.Union(R3);
            this.Region = R;

            RectangleF RF  = R.GetBounds(e.Graphics);
            Rectangle  rec = new Rectangle(0, 0, (int)RF.Width, (int)RF.Height);

            TabControl.TabPaintEventArgs te = default(TabControl.TabPaintEventArgs);

            te = new TabControl.TabPaintEventArgs(e.Graphics, rec, m_Selected, m_Hot, GraphicPath, Width, Height);
            if (TabPaintBackgroundEvent != null) // try to owner draw
            {
                TabPaintBackgroundEvent(this, te);
            }
            System.Drawing.Drawing2D.LinearGradientBrush gb = CreateGradientBrush(new Rectangle(0, 0, this.Width, this.Height), RenderHighColor, RenderLowColor);
            if (!te.Handled)
            {
                e.Graphics.FillPath(gb, GraphicPath);
            }
            gb.Dispose();
            te.Dispose();

            te = new TabControl.TabPaintEventArgs(e.Graphics, rec, m_Selected, m_Hot, GraphicPath, Width, Height);
            if (TabPaintBorderEvent != null) // try to owner draw
            {
                TabPaintBorderEvent(this, te);
            }
            if (!te.Handled)
            {
                if (m_BorderEnhanced)
                {
                    Color c = m_Alignment == TabControl.TabAlignment.Bottom ? RenderLowColor : RenderHighColor;
                    Pen   p = new Pen(c, (float)m_BorderEnhanceWeight);
                    e.Graphics.DrawLines(p, GraphicPath.PathPoints);
                    p.Dispose();
                }
                Pen p1 = new Pen(RenderBorderColor);
                e.Graphics.DrawLines(p1, GraphicPath.PathPoints);
                p1.Dispose();
            }
            te.Dispose();

            e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.None;
            e.Graphics.DrawLine(new Pen(RenderBottomColor), GraphicPath.PathPoints[0], GraphicPath.PathPoints[GraphicPath.PointCount - 1]);
            e.Graphics.SmoothingMode = m_SmoothingMode;

            DrawIcon(e.Graphics);
            DrawText(e.Graphics);
            if (m_CloseButtonVisible)
            {
                DrawCloseButton(e.Graphics);
            }
            this.ResumeLayout();

            // do the memory cleanup
            GraphicPath.Dispose();
            M1.Dispose();
            M2.Dispose();
            M3.Dispose();
            R1.Dispose();
            R2.Dispose();
            R3.Dispose();
            R.Dispose();
            te.Dispose();
            Painting = false;
        }
예제 #16
0
 internal virtual int getDrawType(DrawContext context, System.Drawing.Drawing2D.Matrix transform, ScenicColor color)
 {
     return(DRAW_SIMPLE);
 }
예제 #17
0
 internal override void prepareDraw(DrawContext context, System.Drawing.Drawing2D.Matrix transform)
 {
 }
예제 #18
0
        internal void DrawHorizontal(Chart chart,
                                     Rdl.Runtime.Context context,
                                     Graphics g,
                                     bool centered,
                                     int l, int t, int w, ref int h)
        {
            int majorIntervals = (int)((_maxValue - _minValue) / _majorIntervalValue);
            int minorIntervals = (int)((_maxValue - _minValue) / _minorIntervalValue);

            // Find the tick mark and axis position for the axis.
            int majorTickStart, majorTickHeight, minorTickStart, minorTickHeight, axisPos, axisWidth;

            AdjustAxisPosition(GetAxisThickness(context), out majorTickStart, out majorTickHeight,
                               out minorTickStart, out minorTickHeight,
                               out axisPos, out axisWidth);

            Color color        = Style.W32Color(Style.Color(context));
            Brush brush        = new SolidBrush(color);
            Pen   majorGridPen = new Pen(brush, 1);

            if (MajorGridLines != null)
            {
                majorGridPen = new Pen(new SolidBrush(Style.W32Color(MajorGridLines.Style.Color(context))),
                                       (int)MajorGridLines.Style.BorderWidth.Left(context).points);
            }
            Pen minorGridPen = new Pen(brush, 1);

            if (MinorGridLines != null)
            {
                minorGridPen = new Pen(new SolidBrush(Style.W32Color(MinorGridLines.Style.Color(context))),
                                       (int)MinorGridLines.Style.BorderWidth.Left(context).points);
            }

            Font  font            = Style.GetWindowsFont(context);
            bool  vertical        = false;
            float yMult           = (float)g.DpiY / 72;
            int   labelHeight     = 0;
            float majorEntryWidth = (float)w / majorIntervals;
            float minorEntryWidth = (float)w / minorIntervals;

            // Determine how much vertical space is required for the axis labels.
            if (Visible)
            {
                // Determine if the labels need to be vertical and find the height required for the labels.
                labelHeight = (int)(font.Height * yMult);

                // Determine the amount of space required for the axis labels.
                GetValueLableWidth(context, g, majorIntervals);

                if (_labelWidth > (int)majorEntryWidth)
                {
                    labelHeight = _labelWidth;
                    vertical    = true;
                }
            }

            // If we are showing the grid lines then adjust the tick width to include the whole chart area.
            if (MajorGridLines.ShowGridLines)
            {
                majorTickHeight = h - labelHeight - axisPos - majorTickStart;
            }
            if (MinorGridLines.ShowGridLines)
            {
                minorTickHeight = h - labelHeight - axisPos - minorTickStart;
            }

            // Fill in the background of the plot area.
            g.FillRectangle(new SolidBrush(Style.W32Color(chart.PlotAreaStyle.BackgroundColor(context))),
                            l, t, w, h - (labelHeight + axisWidth));

            // Draw the axis line
            g.DrawLine(new Pen(new SolidBrush(color), GetAxisThickness(context)),
                       new Point(l, t + h - labelHeight - axisPos - (GetAxisThickness(context) >> 1)),
                       new Point(l + w, t + h - labelHeight - axisPos - (GetAxisThickness(context) >> 1)));

            // Loop through the major interval values
            int left = l;

            for (int i = 0; i <= majorIntervals; i++)
            {
                left = l + (int)(i * majorEntryWidth);

                if (Visible)
                {
                    decimal dValue = _minValue + (i * _majorIntervalValue);

                    int center = left;
                    if (centered)
                    {
                        center += (int)(majorEntryWidth / 2);
                    }
                    SizeF size = g.MeasureString(dValue.ToString(), font);
                    if (vertical)
                    {
                        System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
                        path.AddString(dValue.ToString(), font.FontFamily, (int)font.Style, font.Size * yMult,
                                       new Point(center - ((int)size.Width / 2), t + h - labelHeight),
                                       StringFormat.GenericDefault);
                        if (vertical)
                        {
                            System.Drawing.Drawing2D.Matrix matrix = new System.Drawing.Drawing2D.Matrix();
                            matrix.Translate(0 - (size.Width / 2), 0);
                            matrix.RotateAt(-30, new PointF(center, t + h - labelHeight), System.Drawing.Drawing2D.MatrixOrder.Append);
                            path.Transform(matrix);
                        }
                        g.DrawPath(new Pen(brush), path);
                    }
                    else
                    {
                        g.DrawString(dValue.ToString(), font, brush,
                                     center - (int)size.Width / 2, t + h - labelHeight, StringFormat.GenericDefault);
                    }
                }

                if (i > 0)
                {
                    // Draw the major tick mark
                    if (majorTickHeight > 0)
                    {
                        g.DrawLine(majorGridPen,
                                   new Point(left, t + h - labelHeight - (axisWidth >> 1) - majorTickStart),
                                   new Point(left, t + h - labelHeight - (axisWidth >> 1) - majorTickStart - majorTickHeight));
                    }

                    // Draw the minor tick marks
                    if (minorTickHeight > 0)
                    {
                        for (int j = 1; j < minorIntervals / majorIntervals; j++)
                        {
                            g.DrawLine(minorGridPen,
                                       new Point(left + (int)(j * minorEntryWidth), t + h - labelHeight - (axisWidth >> 1) + minorTickStart),
                                       new Point(left + (int)(j * minorEntryWidth), t + h - labelHeight - (axisWidth >> 1) + minorTickStart - minorTickHeight));
                        }
                    }
                }
            }

            h -= labelHeight + ((axisWidth + GetAxisThickness(context)) >> 1);
        }
예제 #19
0
        public override void Draw(int gridSize, Graphics g)
        {
            int deltaX = (End.X - Start.X);
            int deltaY = (End.Y - Start.Y);

            // This is the size of the rectangle that will hold the ellipse
            SizeF arcSizeRotate = new SizeF((float)Length * gridSize, (float)(Radius * 2 * gridSize));

            // Perform the rotations and translations.
            using (System.Drawing.Drawing2D.Matrix transformMatrix = new System.Drawing.Drawing2D.Matrix())
            {
                Point start = Start.ToPoint(gridSize);
                Point end   = End.ToPoint(gridSize);

                // We might need to swap what we consider as start/end.
                if (Start.X > End.X || Start.Y < End.Y)
                {
                    start = End.ToPoint(gridSize);
                    end   = Start.ToPoint(gridSize);
                }

                // Calculate angle from offset.
                double radians = Math.Atan((double)(end.Y - start.Y) / (double)(end.X - start.X));
                double degrees = radians * ((double)180 / Math.PI);

                // Rotate by the specified angle
                transformMatrix.RotateAt((float)degrees, start, System.Drawing.Drawing2D.MatrixOrder.Prepend);

                // Convert back into radians, but with the absolute value for degrees.
                degrees = Math.Abs(degrees) * Math.PI / 180;

                int signX = Math.Sign(deltaX);
                int signY = Math.Sign(deltaY);

                // translate by the width of the line as the box is drawn away from the line
                if (signX == 1 && signY == 1)
                {
                    transformMatrix.Translate(-(float)(Math.Cos(degrees) * (arcSizeRotate.Width)), 0, System.Drawing.Drawing2D.MatrixOrder.Append);
                    transformMatrix.Translate(0, -(float)(Math.Sin(degrees) * (arcSizeRotate.Width)), System.Drawing.Drawing2D.MatrixOrder.Append);
                }

                // always translate on the x axis
                transformMatrix.Translate(0, -(float)(Math.Cos(degrees) * (arcSizeRotate.Height / 2)), System.Drawing.Drawing2D.MatrixOrder.Append);

                // translate on the y axis eiter by adding or substracting depending on the way the line was drawn
                transformMatrix.Translate((signY == signX ? 1 : -1) * (float)(Math.Sin(degrees) * (arcSizeRotate.Height / 2)), 0, System.Drawing.Drawing2D.MatrixOrder.Append);

                //figure out the angle

                int startDegrees = 180;
                if (signX == -1 || (signX == 0 && signY == 1))
                {
                    startDegrees = 0;
                }

                g.Transform = transformMatrix;

                Pen pen = new Pen(new SolidBrush(Color), Width);
                g.DrawArc(pen, new RectangleF(start, arcSizeRotate), (float)(startDegrees), (float)(180));

                g.ResetTransform();
            }
        }
예제 #20
0
        public void TestScale(float tx, float ty, float sx, float sy)
        {
            dsxy = sx;
            matrixd = new System.Drawing.Drawing2D.Matrix();//System.Drawing.Drawing2D.Matrix(1, 0, 0, -1, 0, 0);

            matrixd.Scale(sx, sy, System.Drawing.Drawing2D.MatrixOrder.Append);
            matrixd.Translate(tx, ty, System.Drawing.Drawing2D.MatrixOrder.Append);
        }
예제 #21
0
        private static void DrawGraph(Bitmap bitmap, GleeGraph graph)
        {
            var graphics = Graphics.FromImage(bitmap);

            graphics.Clear(Color.White);

            var matrix = new System.Drawing.Drawing2D.Matrix();

            matrix.Translate(-(float)graph.BoundingBox.Left, -(float)graph.BoundingBox.Bottom);
            graphics.Transform = matrix;

            // Nodes
            foreach (var node in graph.NodeMap.Values)
            {
                ICurve  curve = node.MovedBoundaryCurve;
                Ellipse el    = curve as Ellipse;
                if (el != null)
                {
                    graphics.DrawEllipse(nodePen, new RectangleF((float)el.BBox.Left, (float)el.BBox.Bottom,
                                                                 (float)el.BBox.Width, (float)el.BBox.Height));
                    var font      = (node.Id == startNode) ? startNodeFont : nodeFont;
                    var textBrush = (node.Id == startNode) ? startNodeTextBrush : nodeTextBrush;
                    graphics.DrawString(
                        node.Id,
                        font,
                        textBrush,
                        new RectangleF((float)el.BBox.Left, (float)el.BBox.Bottom,
                                       (float)el.BBox.Width, (float)el.BBox.Height),
                        stringFormat);
                }
            }

            // Edges
            foreach (var edge in graph.Edges)
            {
                ICurve curve = edge.Curve;
                var    c     = curve as Curve;
                if (c != null)
                {
                    foreach (ICurve s in c.Segs)
                    {
                        var l = s as LineSeg;
                        if (l != null)
                        {
                            graphics.DrawLine(edgePen, GleePointToDrawingPoint(l.Start), GleePointToDrawingPoint(l.End));
                        }
                        var cs = s as CubicBezierSeg;
                        if (cs != null)
                        {
                            graphics.DrawBezier(edgePen, GleePointToDrawingPoint(cs.B(0)), GleePointToDrawingPoint(cs.B(1)), GleePointToDrawingPoint(cs.B(2)), GleePointToDrawingPoint(cs.B(3)));
                        }
                    }
                    if (edge.ArrowHeadAtSource)
                    {
                        DrawArrow(edge, edgePen, graphics, edge.Curve.Start, edge.ArrowHeadAtSourcePosition);
                    }
                    if (edge.ArrowHeadAtTarget)
                    {
                        DrawArrow(edge, edgePen, graphics, edge.Curve.End, edge.ArrowHeadAtTargetPosition);
                    }
                    if (c.Segs.Count % 2 == 0)
                    {
                        // Even segs
                        var index = c.Segs.Count / 2;
                        var l     = c.Segs[index] as LineSeg;
                        if (l != null)
                        {
                            var p = GleePointToDrawingPoint(l.End);
                            DrawEdgeLabel(graphics, edge, p.X, p.Y);
                        }
                        var cs = c.Segs[index] as CubicBezierSeg;
                        if (cs != null)
                        {
                            var p = GleePointToDrawingPoint(cs.B(2));
                            DrawEdgeLabel(graphics, edge, p.X, p.Y);
                        }
                    }
                    else
                    {
                        // Uneven segs
                        var index = c.Segs.Count / 2;
                        var l     = c.Segs[index] as LineSeg;
                        if (l != null)
                        {
                            var p1 = GleePointToDrawingPoint(l.Start);
                            var p2 = GleePointToDrawingPoint(l.End);
                            DrawEdgeLabel(graphics, edge, (p2.X - p1.X) / 2, (p2.Y - p1.Y) / 2);
                        }
                        var cs = c.Segs[index] as CubicBezierSeg;
                        if (cs != null)
                        {
                            var p = GleePointToDrawingPoint(cs.B(1));
                            DrawEdgeLabel(graphics, edge, p.X, p.Y);
                        }
                    }
                }
            }
            graphics.Flush();
        }
예제 #22
0
 public void MultiplyTransform(System.Drawing.Drawing2D.Matrix matrix, System.Drawing.Drawing2D.MatrixOrder order)
 {
 }
예제 #23
0
 public void MultiplyTransform(System.Drawing.Drawing2D.Matrix matrix)
 {
 }
예제 #24
0
 public Bitmap GetScaledImage(System.Drawing.Drawing2D.Matrix m)
 {
     return(stage.Gdi.RenderFirstFrame(definition, m));
 }
예제 #25
0
        /// <summary>
        /// Update function of map. Calls Bayes filtering and handles the rotation and translation of all map objects.
        /// </summary>
        private void Update(object sender, EventArgs e)
        {
            lock (robot.mapLock)
            {
                Bayes(true, preySensor, ref preyProbability);
                Bayes(false, obstacleSensor, ref obstacleProbability);
                bBayes = new Bitmap(bMap.Size.Width, bMap.Size.Height);
                SetNewRovioPosition();

                // Run AStar if there is a suitable destination and draw it on the map.
                using (graphics = Graphics.FromImage(bBayes))
                {
                    AStar astar = new AStar(finalMap.GetLength(0), finalMap.GetLength(1));
                    astar.Build(finalMap, new DPoint(destination.X, destination.Y), new DPoint((picBoxRovio.Location.X / 10) + (picBoxRovio.Width / 10 / 2), picBoxRovio.Location.Y / 10));
                    aStarPath = astar.path;
                    for (int i = 0; i < maxX; i++)
                    {
                        for (int j = 0; j < maxY; j++)
                        {
                            graphics.FillRectangle(new SolidBrush(DColor.FromArgb((int)(preyProbability[i, j] * 255), System.Drawing.Color.DarkRed)), new DRectangle(i * 10, j * 10, 10, 10));
                            graphics.FillRectangle(new SolidBrush(DColor.FromArgb((int)(obstacleProbability[i, j] * 255), System.Drawing.Color.DarkBlue)), new DRectangle(i * 10, j * 10, 10, 10));
                            if (astar.inPath[i, j])
                            {
                                graphics.FillRectangle(new SolidBrush(DColor.Red), new DRectangle(i * 10, j * 10, 10, 10));
                            }
                        }
                    }
                }
                picBoxBayes.Image = bBayes;

                // Check which cells are within the viewing cone.
                if (viewConePoints != null)
                {
                    for (int i = 0; i < maxX; i++)
                    {
                        for (int j = 0; j < maxY; j++)
                        {
                            DPoint a = new DPoint(i * 10 + 1, j * 10 + 1);             // Top left
                            DPoint b = new DPoint((i + 1) * 10 - 1, j * 10 + 1);       // Top right
                            DPoint c = new DPoint(i * 10 + 1, (j + 1) * 10 - 1);       // Bottom left
                            DPoint d = new DPoint((i + 1) * 10 - 1, (j + 1) * 10 - 1); // Bottom right
                            if (!(PointInPolygon(a, viewConePoints) || PointInPolygon(b, viewConePoints) ||
                                  PointInPolygon(c, viewConePoints) || PointInPolygon(d, viewConePoints)))
                            {
                                isCellVisible[i, j] = false;
                            }
                            else
                            {
                                preySensor[i, j]     = false;
                                obstacleSensor[i, j] = false;
                                isCellVisible[i, j]  = true;
                            }
                        }
                    }
                }

                if (robot.GetType() == typeof(Rovio.PredatorMap))
                {
                    if (robot.IsPreySeen())
                    {
                        FindRelativeLocation(picBoxPrey, robot.preyRectangle, robot.GetPreyDistance(), 1, 1);

                        try
                        {
                            preySensor[(int)((picBoxPrey.Location.X / 10) + 1.5), (int)((picBoxPrey.Location.Y / 10) + 1.5)] = true;
                        } catch { }
                    }
                    else
                    {
                        picBoxPrey.Hide();
                    }

                    if ((robot as Rovio.BaseArena).IsObstacleSeen())
                    {
                        // Find obstacle position relative to the Rovio's position.
                        FindRelativeLocation(picBoxObstacle, robot.obstacleRectangle, robot.GetObstacleDistance(), 40, 3);
                        try
                        {
                            int p = (int)((picBoxObstacle.Location.X / 10) + 0.5);
                            int q = (int)((picBoxObstacle.Location.Y / 10) + 0.5);

                            // Populate 3x3 area with the obstacle.
                            for (int i = -1; i <= 1; i++)
                            {
                                for (int j = -1; j <= 1; j++)
                                {
                                    obstacleSensor[(int)((picBoxObstacle.Location.X / 10) + i), (int)((picBoxObstacle.Location.Y / 10) + j)] = true;
                                }
                            }
                        }
                        catch { }
                    }
                    else
                    {
                        picBoxObstacle.Hide();
                    }
                }


                // Rotate the Rovio icon to the angle that the robot physically faces.
                System.Drawing.Drawing2D.Matrix matrixRovio = new System.Drawing.Drawing2D.Matrix();
                matrixRovio.RotateAt((float)robot.cumulativeAngle, new System.Drawing.Point(picBoxRovio.Location.X + (picBoxRovio.Size.Width / 2), picBoxRovio.Location.Y + (picBoxRovio.Size.Height / 2)));
                matrixRovio.Translate(0f, -0f);
                DPoint[] rovioMovementPoints = { new DPoint(picBoxRovio.Location.X + (picBoxRovio.Size.Width / 2),      picBoxRovio.Location.Y + (picBoxRovio.Size.Height / 2)),
                                                 new DPoint(picBoxRovio.Location.X + (picBoxRovio.Size.Width / 2) - 69, picBoxRovio.Location.Y - 150),
                                                 new DPoint(picBoxRovio.Location.X + (picBoxRovio.Size.Width / 2) + 69, picBoxRovio.Location.Y - 150) };
                matrixRovio.TransformPoints(rovioMovementPoints);

                if ((robot as Rovio.BaseArena).IsObstacleSeen())
                {
                    // Get the left and right points of the obstacle in the viewing cone and orientate accordingly.
                    DPoint leftPoint  = new DPoint(picBoxObstacle.Location.X - (picBoxObstacle.Width / 2), picBoxObstacle.Location.Y - 15);
                    DPoint rightPoint = leftPoint;
                    using (matrix = new System.Drawing.Drawing2D.Matrix())
                    {
                        matrix.RotateAt((float)robot.cumulativeAngle, leftPoint);
                        matrix.Translate(0, -0f);

                        DPoint[] tempPointArr = { leftPoint };
                        matrix.TransformPoints(tempPointArr);
                        leftPoint = tempPointArr[0];

                        // Transform the right point relative to the position of the left.
                        matrix = new System.Drawing.Drawing2D.Matrix();
                        matrix.RotateAt((float)robot.cumulativeAngle, leftPoint);
                        matrix.Translate(30, 0);
                        tempPointArr[0] = new DPoint(0, 0);
                        matrix.TransformPoints(tempPointArr);
                        rightPoint = tempPointArr[0];
                    }

                    // Check if all points are still within the viewing cone. If not, skip over them.
                    if (PointInPolygon(leftPoint, rovioMovementPoints) && PointInPolygon(rightPoint, rovioMovementPoints))
                    {
                        rovioMovementPoints = new DPoint[] { rovioMovementPoints[0], rovioMovementPoints[1], leftPoint, rightPoint, rovioMovementPoints[2] }
                    }
                    ;
                }


                viewConePoints = rovioMovementPoints;
                Bitmap rotated = new Bitmap(bRovio.Width + 70, bRovio.Height + 70);
                rotated.SetResolution(bRovio.HorizontalResolution, bRovio.VerticalResolution);

                using (graphics = Graphics.FromImage(rotated))
                {
                    graphics.TranslateTransform(bRovio.Width / 2, bRovio.Height / 2);
                    graphics.RotateTransform((float)robot.cumulativeAngle);
                    graphics.TranslateTransform(-bRovio.Width / 2, -bRovio.Height / 2);
                    graphics.DrawImage(bRovio, new DPoint(0, 0));

                    picBoxRovio.Size  = new Size(27, 24);
                    picBoxRovio.Image = rotated;

                    picBoxCone.Location = new DPoint(picBoxRovio.Location.X - (bCone.Width / 2) + (bRovio.Width / 2), picBoxRovio.Location.Y - bCone.Height + (bRovio.Height / 2));
                    picBoxCone.Size     = new Size(900, 500);
                    picBoxCone.Image    = rotated;

                    picBoxCone.Location = new DPoint(0, 0);
                    picBoxCone.Size     = new Size(260, 300);
                }

                Bitmap newCone = new Bitmap(260, 300);
                using (graphics = Graphics.FromImage(newCone))
                {
                    graphics.FillPolygon(new SolidBrush(DColor.FromArgb(100, DColor.ForestGreen)), viewConePoints);
                    picBoxCone.Image = newCone;
                }
            }
        }
예제 #26
0
 public static v2 TransformPoint(this Matrix m, v2 pt)
 {
     return(v2.From(m.TransformPoint(pt.ToPointF())));
 }
예제 #27
0
        public List<Point> ToPoints(
    float angle,
    Rectangle rect)
        {
            // Create a GraphicsPath.
            System.Drawing.Drawing2D.GraphicsPath path =
                new System.Drawing.Drawing2D.GraphicsPath();

            path.AddRectangle(rect);

            // Declare a matrix that will be used to rotate the text.
            System.Drawing.Drawing2D.Matrix rotateMatrix =
                new System.Drawing.Drawing2D.Matrix();

            // Set the rotation angle and starting point for the text.
            rotateMatrix.RotateAt(180.0F, new PointF(10.0F, 100.0F));

            // Transform the text with the matrix.
            path.Transform(rotateMatrix);

            List<Point> results = new List<Point>();
            foreach(PointF p in path.PathPoints)
            {
                results.Add(new Point((int)p.X, (int)p.Y));
            }

            path.Dispose();

            return results;
        }
예제 #28
0
파일: D2dGraphics.cs 프로젝트: sbambach/ATF
 /// <summary>
 /// Applies same transform to GDI</summary>
 private void ApplyXformToGdi()
 {
     using (var xform = new System.Drawing.Drawing2D.Matrix(m_xform.M11, m_xform.M12, m_xform.M21, m_xform.M22
             , m_xform.DX, m_xform.DY))
     {
         m_graphics.Transform = xform;
     }
 }
 /// <summary>
 /// Gives subclasses an opportunity to perform a post-transform transformation.
 /// </summary>
 protected virtual void CalculatePostTransform(Matrix cumulativeTransform)
 {
     cumulativeTransform.Translate(-_centerOfRotationXY.X, -_centerOfRotationXY.Y);
 }
        public static void Run()
        {
            // ExStart:ImageInformation
            // The path to the documents directory.
            string dataDir = RunExamples.GetDataDir_AsposePdf_Images();

            // Load the source PDF file
            Document doc = new Document(dataDir + "ImageInformation.pdf");

            // Define the default resolution for image
            int defaultResolution = 72;

            System.Collections.Stack graphicsState = new System.Collections.Stack();
            // Define array list object which will hold image names
            System.Collections.ArrayList imageNames = new System.Collections.ArrayList(doc.Pages[1].Resources.Images.Names);
            // Insert an object to stack
            graphicsState.Push(new System.Drawing.Drawing2D.Matrix(1, 0, 0, 1, 0, 0));

            // Get all the operators on first page of document
            foreach (Operator op in doc.Pages[1].Contents)
            {
                // Use GSave/GRestore operators to revert the transformations back to previously set
                Operator.GSave    opSaveState    = op as Operator.GSave;
                Operator.GRestore opRestoreState = op as Operator.GRestore;
                // Instantiate ConcatenateMatrix object as it defines current transformation matrix.
                Operator.ConcatenateMatrix opCtm = op as Operator.ConcatenateMatrix;
                // Create Do operator which draws objects from resources. It draws Form objects and Image objects
                Operator.Do opDo = op as Operator.Do;

                if (opSaveState != null)
                {
                    // Save previous state and push current state to the top of the stack
                    graphicsState.Push(((System.Drawing.Drawing2D.Matrix)graphicsState.Peek()).Clone());
                }
                else if (opRestoreState != null)
                {
                    // Throw away current state and restore previous one
                    graphicsState.Pop();
                }
                else if (opCtm != null)
                {
                    System.Drawing.Drawing2D.Matrix cm = new System.Drawing.Drawing2D.Matrix(
                        (float)opCtm.Matrix.A,
                        (float)opCtm.Matrix.B,
                        (float)opCtm.Matrix.C,
                        (float)opCtm.Matrix.D,
                        (float)opCtm.Matrix.E,
                        (float)opCtm.Matrix.F);

                    // Multiply current matrix with the state matrix
                    ((System.Drawing.Drawing2D.Matrix)graphicsState.Peek()).Multiply(cm);

                    continue;
                }
                else if (opDo != null)
                {
                    // In case this is an image drawing operator
                    if (imageNames.Contains(opDo.Name))
                    {
                        System.Drawing.Drawing2D.Matrix lastCTM = (System.Drawing.Drawing2D.Matrix)graphicsState.Peek();
                        // Create XImage object to hold images of first pdf page
                        XImage image = doc.Pages[1].Resources.Images[opDo.Name];

                        // Get image dimensions
                        double scaledWidth  = Math.Sqrt(Math.Pow(lastCTM.Elements[0], 2) + Math.Pow(lastCTM.Elements[1], 2));
                        double scaledHeight = Math.Sqrt(Math.Pow(lastCTM.Elements[2], 2) + Math.Pow(lastCTM.Elements[3], 2));
                        // Get Height and Width information of image
                        double originalWidth  = image.Width;
                        double originalHeight = image.Height;

                        // Compute resolution based on above information
                        double resHorizontal = originalWidth * defaultResolution / scaledWidth;
                        double resVertical   = originalHeight * defaultResolution / scaledHeight;

                        // Display Dimension and Resolution information of each image
                        Console.Out.WriteLine(
                            string.Format(dataDir + "image {0} ({1:.##}:{2:.##}): res {3:.##} x {4:.##}",
                                          opDo.Name, scaledWidth, scaledHeight, resHorizontal,
                                          resVertical));
                    }
                }
            }
            // ExEnd:ImageInformation
        }
예제 #31
0
        public void MouseMoveUpdate(object sender, System.Windows.Input.MouseEventArgs e)
        {
            double gapX, gapY, x, y;

            if (shapeLib.Data.gdc.bmove)
            {
                gapX = Math.Abs(shapeLib.Data.currShape.controlBtn4.X + shapeLib.Data.currShape.controlBtn1.X) / 2.0;
                gapY = Math.Abs(shapeLib.Data.currShape.controlBtn4.Y + shapeLib.Data.currShape.controlBtn1.Y) / 2.0;
                x    = e.GetPosition(shapeLib.Data.mygrid).X;
                y    = e.GetPosition(shapeLib.Data.mygrid).Y;
                shapeLib.Data.currShape.controlBtn4.X = shapeLib.Data.currShape.controlBtn4.X + (x - gapX);
                shapeLib.Data.currShape.controlBtn4.Y = shapeLib.Data.currShape.controlBtn4.Y + (y - gapY);
                shapeLib.Data.currShape.controlBtn1.X = shapeLib.Data.currShape.controlBtn1.X + (x - gapX);
                shapeLib.Data.currShape.controlBtn1.Y = shapeLib.Data.currShape.controlBtn1.Y + (y - gapY);
                shapeLib.Data.currShape.controlBtn2.X = shapeLib.Data.currShape.controlBtn2.X + (x - gapX);
                shapeLib.Data.currShape.controlBtn2.Y = shapeLib.Data.currShape.controlBtn2.Y + (y - gapY);
                shapeLib.Data.currShape.controlBtn3.X = shapeLib.Data.currShape.controlBtn3.X + (x - gapX);
                shapeLib.Data.currShape.controlBtn3.Y = shapeLib.Data.currShape.controlBtn3.Y + (y - gapY);

                shapeLib.Data.currShape.redraw(1);
            }

            if (shapeLib.Data.gdc.bbegrotate)
            {
                gapX = Math.Abs(shapeLib.Data.currShape.controlBtn4.X + shapeLib.Data.currShape.controlBtn1.X) / 2.0;
                gapY = Math.Abs(shapeLib.Data.currShape.controlBtn4.Y + shapeLib.Data.currShape.controlBtn1.Y) / 2.0;

                x = e.GetPosition(shapeLib.Data.mygrid).X;
                y = e.GetPosition(shapeLib.Data.mygrid).Y;

                double dx           = x - gapX;
                double dy           = y - gapY;
                double angle        = Math.Atan2(dy, dx);
                double CurrentAngle = angle * 180 / Math.PI;

                CurrentAngle = CurrentAngle - shapeLib.Data.gdc.totalAngle;


                System.Drawing.Drawing2D.Matrix rotate_at_center = new
                                                                   System.Drawing.Drawing2D.Matrix();
                rotate_at_center.RotateAt((float )CurrentAngle, new System.Drawing.PointF((float)gapX, (float)gapY));
                PointF[] myArray =
                {
                    new PointF((float)shapeLib.Data.currShape.controlBtn1.X, (float)shapeLib.Data.currShape.controlBtn1.Y),
                    new PointF((float)shapeLib.Data.currShape.controlBtn2.X, (float)shapeLib.Data.currShape.controlBtn2.Y),
                    new PointF((float)shapeLib.Data.currShape.controlBtn3.X, (float)shapeLib.Data.currShape.controlBtn3.Y),
                    new PointF((float)shapeLib.Data.currShape.controlBtn4.X, (float)shapeLib.Data.currShape.controlBtn4.Y)
                };

                rotate_at_center.TransformPoints(myArray);

                shapeLib.Data.currShape.controlBtn1.X = myArray[0].X;
                shapeLib.Data.currShape.controlBtn1.Y = myArray[0].Y;
                shapeLib.Data.currShape.controlBtn2.X = myArray[1].X;
                shapeLib.Data.currShape.controlBtn2.Y = myArray[1].Y;
                shapeLib.Data.currShape.controlBtn3.X = myArray[2].X;
                shapeLib.Data.currShape.controlBtn3.Y = myArray[2].Y;
                shapeLib.Data.currShape.controlBtn4.X = myArray[3].X;
                shapeLib.Data.currShape.controlBtn4.Y = myArray[3].Y;


                shapeLib.Data.gdc.totalAngle += CurrentAngle;


                shapeLib.Data.currShape.redraw(1);
            }



            //  throw new NotImplementedException();
        }
예제 #32
0
 public CachedFont(System.Drawing.Font font, System.Drawing.Drawing2D.Matrix transform)
 {
     this.font      = font;
     this.transform = transform;
 }
예제 #33
0
        public virtual void  walk(PathWalker walker, System.Drawing.Drawing2D.Matrix errorMatrix, double error)
        {
            //UPGRADE_TODO: Interface 'java.awt.geom.PathIterator' was converted to 'System.Drawing.Drawing2D.GraphicsPathIterator' which has a different behavior. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1073_3"'
            //UPGRADE_TODO: Method 'java.awt.Shape.getPathIterator' was converted to 'System.Drawing.Drawing2D.GraphicsPathIterator.GraphicsPathIterator' which has a different behavior. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1073_javaawtShapegetPathIterator_javaawtgeomAffineTransform_double_3"'
            System.Drawing.Drawing2D.GraphicsPathIterator itr = new System.Drawing.Drawing2D.GraphicsPathIterator(shape);
            double[] point = new double[6];
            int      i     = 0;

            System.Drawing.Drawing2D.Matrix inv;
            double m00, m01, m10, m11, dx, dy;

            try
            {
                System.Drawing.Drawing2D.Matrix temp_Matrix;
                temp_Matrix = new System.Drawing.Drawing2D.Matrix();
                temp_Matrix = errorMatrix.Clone();
                temp_Matrix.Invert();
                inv = temp_Matrix;
            }
            catch (System.Exception e)
            {
                return;
            }

            m00 = (float)inv.Elements.GetValue(0);
            m01 = (float)inv.Elements.GetValue(2);
            m10 = (float)inv.Elements.GetValue(1);
            m11 = (float)inv.Elements.GetValue(3);
            dx  = (System.Single)inv.OffsetX;
            dy  = (System.Single)inv.OffsetY;

            //UPGRADE_ISSUE: Method 'java.awt.geom.PathIterator.isDone' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaawtgeomPathIteratorisDone_3"'
            while (!itr.isDone())
            {
                //UPGRADE_ISSUE: Method 'java.awt.geom.PathIterator.currentSegment' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaawtgeomPathIteratorcurrentSegment_double[]_3"'
                int type = itr.currentSegment(point);

                //UPGRADE_ISSUE: Method 'java.awt.geom.PathIterator.next' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaawtgeomPathIteratornext_3"'
                itr.next();
                //UPGRADE_ISSUE: Field 'java.awt.geom.PathIterator.SEG_MOVETO' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaawtgeomPathIteratorSEG_MOVETO_f_3"'
                if (type == PathIterator.SEG_MOVETO)
                {
                    if (i > 0)
                    {
                        walk(walker, points, i, false);
                        i = 0;
                    }
                    points[i++] = m00 * point[0] + m01 * point[1] + dx;
                    points[i++] = m10 * point[0] + m11 * point[1] + dy;
                }
                else
                {
                    //UPGRADE_ISSUE: Field 'java.awt.geom.PathIterator.SEG_LINETO' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaawtgeomPathIteratorSEG_LINETO_f_3"'
                    if (type == PathIterator.SEG_LINETO)
                    {
                        points[i++] = m00 * point[0] + m01 * point[1] + dx;
                        points[i++] = m10 * point[0] + m11 * point[1] + dy;
                    }
                    else
                    {
                        //UPGRADE_ISSUE: Field 'java.awt.geom.PathIterator.SEG_CLOSE' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaawtgeomPathIteratorSEG_CLOSE_f_3"'
                        if (type == PathIterator.SEG_CLOSE)
                        {
                            if (i > 0)
                            {
                                walk(walker, points, i, true);
                                i = 0;
                            }
                        }
                    }
                }
            }
            if (i > 0)
            {
                walk(walker, points, i, false);
                i = 0;
            }
        }
예제 #34
0
 internal abstract void draw(DrawContext context, System.Drawing.Drawing2D.Matrix transform, ScenicColor color);
예제 #35
0
 /// <summary> 一个点绕中心点旋转一定角度到达的新坐标
 /// </summary>
 /// <param name="p">点</param>
 /// <param name="center">中心点</param>
 /// <param name="angle">角度</param>
 /// <returns>旋转后的点</returns>
 public static PointF PointRotate(PointF p, PointF center, float angle)
 {
     System.Drawing.Drawing2D.Matrix m = new System.Drawing.Drawing2D.Matrix();
     m.RotateAt(angle, new PointF(center.X - p.X, center.Y - p.Y));
     return(new PointF(p.X + m.OffsetX, p.Y + m.OffsetY));
 }
예제 #36
0
 internal override int getDrawType(DrawContext context, System.Drawing.Drawing2D.Matrix transform)
 {
     return(getDrawType(context, transform, color));
 }
예제 #37
0
 /// <summary>
 /// Coberts a <see cref="System.Drawing.Drawing2D.Matrix"/> to <see cref="Fusee.Math.Core.Matrix2F"/>.
 /// </summary>
 /// <param name="value">A <see cref="System.Drawing.Drawing2D.Matrix"/> instance to convert.</param>
 /// <returns>A <see cref="Fusee.Math.Core.Matrix2F"/> instance.</returns>
 public static Fusee.Math.Core.Matrix2F ToGDI(System.Drawing.Drawing2D.Matrix value)
 {
     return(new Fusee.Math.Core.Matrix2F(
                value.Elements[0], value.Elements[1],
                value.Elements[2], value.Elements[3]));
 }
예제 #38
0
 public virtual System.Drawing.Rectangle getBounds(System.Drawing.Drawing2D.Matrix transform)
 {
     System.Drawing.Rectangle tempAux = System.Drawing.Rectangle.Truncate(shape.GetBounds());
     //UPGRADE_NOTE: ref keyword was added to struct-type parameters. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1303_3"'
     return(Util.transform(transform, ref tempAux));
 }
예제 #39
0
        // Generates the close button image
        private Bitmap GetButton()
        {
            System.Drawing.Point[] Points            = new System.Drawing.Point[] { new Point(1, 0), new Point(3, 0), new Point(5, 2), new Point(7, 0), new Point(9, 0), new Point(6, 3), new Point(6, 4), new Point(9, 7), new Point(7, 7), new Point(5, 5), new Point(3, 7), new Point(1, 7), new Point(4, 4), new Point(4, 3) };
            System.Drawing.Drawing2D.GraphicsPath gp = new System.Drawing.Drawing2D.GraphicsPath();
            Color  bch = new Color();
            Color  bcl = new Color();
            Color  bc  = new Color();
            Color  fc  = new Color();
            Bitmap B   = default(Bitmap);

            System.Drawing.Drawing2D.Matrix m    = new System.Drawing.Drawing2D.Matrix();
            System.Drawing.Point[]          path = new System.Drawing.Point[] { new Point(0, 1), new Point(1, 0), new Point(15, 0), new Point(16, 1), new Point(16, 14), new Point(15, 15), new Point(1, 15), new Point(0, 14) };
            Graphics g = default(Graphics);

            if (MouseOverCloseButton)
            {
                bch = Helper.RenderColors.TabCloseButtonBackHighColorHot(m_RenderMode, CloseButtonBackHighColorHot);
                bcl = Helper.RenderColors.TabCloseButtonBackLowColorHot(m_RenderMode, CloseButtonBackLowColorHot);
                bc  = Helper.RenderColors.TabCloseButtonBorderColorHot(m_RenderMode, CloseButtonBorderColorHot);
                fc  = Helper.RenderColors.TabCloseButtonForeColorHot(m_RenderMode, CloseButtonForeColorHot);
            }
            else if (m_Selected)
            {
                bch = Helper.RenderColors.TabCloseButtonBackHighColor(m_RenderMode, CloseButtonBackHighColor);
                bcl = Helper.RenderColors.TabCloseButtonBackLowColor(m_RenderMode, CloseButtonBackLowColor);
                bc  = Helper.RenderColors.TabCloseButtonBorderColor(m_RenderMode, CloseButtonBorderColor);
                fc  = Helper.RenderColors.TabCloseButtonForeColor(m_RenderMode, CloseButtonForeColor);
            }
            else
            {
                bch = Helper.RenderColors.TabCloseButtonBackHighColorDisabled(m_RenderMode, CloseButtonBackHighColorDisabled);
                bcl = Helper.RenderColors.TabCloseButtonBackLowColorDisabled(m_RenderMode, CloseButtonBackLowColorDisabled);
                bc  = Helper.RenderColors.TabCloseButtonBorderColorDisabled(m_RenderMode, CloseButtonBorderColorDisabled);
                fc  = Helper.RenderColors.TabCloseButtonForeColorDisabled(m_RenderMode, CloseButtonForeColorDisabled);
            }
            B = new Bitmap(17, 17);
            B.MakeTransparent();
            g = Graphics.FromImage(B);
            // draw the border and background
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
            System.Drawing.Drawing2D.LinearGradientBrush l = new System.Drawing.Drawing2D.LinearGradientBrush(new Point(0, 0), new Point(0, 15), bch, bcl);
            g.FillPolygon(l, path);
            Pen p = new Pen(bc);

            g.DrawPolygon(p, path);
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.Default;
            // draw the foreground
            gp.AddPolygon(Points);
            m.Translate(3, 4);
            gp.Transform(m);
            p.Dispose();
            p = new Pen(fc);
            g.DrawPolygon(p, gp.PathPoints);
            SolidBrush sb = new SolidBrush(fc);

            g.FillPolygon(sb, gp.PathPoints);
            sb.Dispose();
            p.Dispose();
            gp.Dispose();
            g.Dispose();
            m.Dispose();
            return(B);
        }
예제 #40
0
            //private   Matrix matrix;
            //private readonly Matrix _inverse;

            /// <summary>
            /// Creates an instance of this class
            /// </summary>
            /// <param name="matrix"><see cref="T:System.Drawing.Drawing2D.Matrix"/> that holds the coefficients and for the coordinate transformation</param>
            public AffineCoordinateTransformation2D(System.Drawing.Drawing2D.Matrix matrix)
                : this(
                    matrix.Elements[0], matrix.Elements[1], matrix.OffsetX,
                    matrix.Elements[2], matrix.Elements[3], matrix.OffsetY)
            {
            }
예제 #41
0
        internal static SharpMap.Map InitializeMap(float angle, string[] filenames)
        {
            var map = new SharpMap.Map();

            try
            {
                foreach (var filename in filenames)
                {
                    var connectionString = string.Format("Data Source={0}", filename);
                    foreach (var provider in SharpMap.Data.Providers.SpatiaLite.GetSpatialTables(connectionString))
                    {
                        map.Layers.Add(
                            new SharpMap.Layers.VectorLayer(
                                string.Format("{0} - {1}", provider.Table, provider.GeometryColumn), provider) { Style = LayerTools.GetRandomVectorStyle() });
                    }
                }
                if (map.Layers.Count > 0)
                {
                    map.ZoomToExtents();

                    System.Drawing.Drawing2D.Matrix mat = new System.Drawing.Drawing2D.Matrix();
                    mat.RotateAt(angle, map.WorldToImage(map.Center));
                    map.MapTransform = mat;
                    return map;
                }
            }
            catch (System.Exception ex)
            {
                System.Diagnostics.Trace.WriteLine(ex.Message);
            }
            return null;
        }
예제 #42
0
            public void TestAffineTransform2D()
            {
                //Setup some affine transformation
                System.Drawing.Drawing2D.Matrix matrix = new System.Drawing.Drawing2D.Matrix();
                matrix.RotateAt(30, new System.Drawing.PointF(0, 0));
                matrix.Translate(-20, -20, System.Drawing.Drawing2D.MatrixOrder.Append);
                matrix.Shear(0.95f, -0.2f, System.Drawing.Drawing2D.MatrixOrder.Append);

                //Create some random sample data
                CreatingData cd = new CreatingData();

                SharpMap.Data.FeatureDataTable fdt1 =
                    cd.CreatePointFeatureDataTableFromArrays(GetRandomOrdinates(80, -180, 180),
                                                             GetRandomOrdinates(80, -90, 90), null);

                //Clone random sample data and apply affine transformation on it
                SharpMap.Data.FeatureDataTable fdt2 = TransformedFeatureDataTable(matrix, fdt1);

                //Get affine transformation with LeastSquaresTransform
                SharpMap.Utilities.LeastSquaresTransform lst = new SharpMap.Utilities.LeastSquaresTransform();

                //Add at least three corresponding points
                lst.AddInputOutputPoint(
                    ((SharpMap.Data.FeatureDataRow)fdt1.Rows[0]).Geometry as SharpMap.Geometries.Point,
                    ((SharpMap.Data.FeatureDataRow)fdt2.Rows[0]).Geometry as SharpMap.Geometries.Point);

                lst.AddInputOutputPoint(
                    ((SharpMap.Data.FeatureDataRow)fdt1.Rows[39]).Geometry as SharpMap.Geometries.Point,
                    ((SharpMap.Data.FeatureDataRow)fdt2.Rows[39]).Geometry as SharpMap.Geometries.Point);

                lst.AddInputOutputPoint(
                    ((SharpMap.Data.FeatureDataRow)fdt1.Rows[79]).Geometry as SharpMap.Geometries.Point,
                    ((SharpMap.Data.FeatureDataRow)fdt2.Rows[79]).Geometry as SharpMap.Geometries.Point);

                /*
                 * //Get affine transformation calculates mean points to improve accuaracy
                 * //Unfortunately the result is not very good, so, since I know better I manually set these
                 * //mean points.
                 * lst.SetMeanPoints(new SharpMap.Geometries.Point(0, 0),
                 *                new SharpMap.Geometries.Point(matrix.OffsetX, matrix.OffsetY));
                 */

                //Create Affine
                AffineCoordinateTransformation2D at2 = new AffineCoordinateTransformation2D(lst.GetAffineTransformation());

                //Create Map
                SharpMap.Map map = new SharpMap.Map(new System.Drawing.Size(720, 360));

                //Add not transformed layer
                map.Layers.Add(new SharpMap.Layers.VectorLayer("L1",
                                                               new SharpMap.Data.Providers.GeometryFeatureProvider(fdt1)));
                ((SharpMap.Layers.VectorLayer)map.Layers[0]).Style.Symbol =
                    new System.Drawing.Bitmap(@"..\..\..\DemoWinForm\Resources\flag.png");

                //Add transformed layer
                map.Layers.Add(new SharpMap.Layers.VectorLayer("L2",
                                                               new SharpMap.Data.Providers.GeometryFeatureProvider(fdt2)));
                ((SharpMap.Layers.VectorLayer)map.Layers[1]).Style.Symbol =
                    new System.Drawing.Bitmap(@"..\..\..\DemoWinForm\Resources\women.png");

                //Render map
                map.ZoomToExtents();

                //Get map and save to file
                var bmp = (System.Drawing.Bitmap)map.GetMap();

                bmp.Save("affinetransform1.bmp");

                //we want to reverse the previously applied transformation.
                ((SharpMap.Layers.VectorLayer)map.Layers[1]).CoordinateTransformation = (AffineCoordinateTransformation2D)at2.Inverse();

                //Render map
                map.ZoomToExtents();

                //Get map and save to file
                bmp = (System.Drawing.Bitmap)map.GetMap();
                bmp.Save("affinetransform2.bmp");
                //Hopefully women cover flags ;-).
            }
		public override bool CalculateCalloutLocation(out PointF location, out CoordinateSystem coordinateSystem)
		{
			if (this.Roi.Points.Count < 3 || string.IsNullOrEmpty(this.Callout.Text))
				base.Callout.Visible = false;
			else
				base.Callout.Visible = true;

			if (!base.Callout.Visible || _userMovedCallout)
				return base.CalculateCalloutLocation(out location, out coordinateSystem);

			SizeF calloutOffsetDestination = GetCalloutOffsetDestination();

			coordinateSystem = CoordinateSystem.Destination;
			base.AnnotationGraphic.CoordinateSystem = coordinateSystem;

			// first, move the callout by the same amount the vertex moved (if it moved at all).
			location = base.Callout.TextLocation + calloutOffsetDestination;

			PointF start = this.Roi.Points[0];
			PointF vertex = this.Roi.Points[1];
			PointF end = this.Roi.Points[2];

			base.AnnotationGraphic.ResetCoordinateSystem();

			double vectorAngle = -Vector.SubtendedAngle(start, vertex, end) / 2 + 180;

			PointF[] points = new PointF[] { start, end };

			using (Matrix rotation = new Matrix())
			{
				rotation.Rotate((float) vectorAngle);
				rotation.Translate(-vertex.X, -vertex.Y);
				rotation.TransformPoints(points);
			}

			float calloutMagnitude = new Vector3D(location.X - vertex.X, location.Y - vertex.Y, 0).Magnitude;

			Vector3D startVector = new Vector3D(points[0].X, points[0].Y, 0);
			if (FloatComparer.AreEqual(startVector.Magnitude, 0F, 0.01F))
				startVector = new Vector3D(-1, 0, 0);

			startVector = startVector / startVector.Magnitude * calloutMagnitude;

			location = new PointF(startVector.X + vertex.X, startVector.Y + vertex.Y);

			return true;
		}
예제 #44
0
        public List<Point> ToPoints(
            float angle,
            Rectangle rect)
        {
            // Graphics g = Graphics.FromImage(this.Image);
            Graphics g = Graphics.FromHwnd(this.Handle);

            List<Point> source_points = new List<Point>();
            source_points.Add(new Point(rect.X, rect.Y));
            source_points.Add(new Point(rect.X + rect.Width, rect.Y));
            source_points.Add(new Point(rect.X +rect.Width, rect.Y + rect.Height));
            source_points.Add(new Point(rect.X, rect.Y + rect.Height));
            Point[] pts = source_points.ToArray();

            Rectangle display_rect = GetPictureBoxZoomSize();
            float x_ratio = (float)display_rect.Width / (float)this.Image.Width;
            float y_ratio = (float)display_rect.Height / (float)this.Image.Height;

            System.Drawing.Drawing2D.Matrix rotateMatrix =
    new System.Drawing.Drawing2D.Matrix();
            // Set the rotation angle and starting point for the text.
            rotateMatrix.RotateAt(angle, new PointF(this.Image.Width / 2, this.Image.Height / 2));
            //rotateMatrix.RotateAt(angle, new PointF(0, 0));

            g.MultiplyTransform(rotateMatrix);

            // g.ScaleTransform(x_ratio, y_ratio);
            // g.ScaleTransform((float)1.1, (float)1.1);
            // g.RotateTransform(angle);
            g.TransformPoints(System.Drawing.Drawing2D.CoordinateSpace.World, System.Drawing.Drawing2D.CoordinateSpace.Device, pts);
            return pts.ToList();
        }
예제 #45
0
파일: The3d.cs 프로젝트: henon/manic_digger
        public void Draw2dTextures(Draw2dData[] todraw, int textureid, float angle)
        {
            GL.PushAttrib(AttribMask.ColorBufferBit);
            GL.BindTexture(TextureTarget.Texture2D, textureid);
            GL.Enable(EnableCap.Texture2D);
            GL.Disable(EnableCap.DepthTest);

            VertexPositionTexture[] vertices;
            ushort[] indices;
            if (todraw.Length >= draw2dtexturesMAX)
            {
                vertices = new VertexPositionTexture[todraw.Length * 4];
                indices = new ushort[todraw.Length * 4];
            }
            else
            {
                if (draw2dtexturesVertices == null)
                {
                    draw2dtexturesVertices = new VertexPositionTexture[draw2dtexturesMAX * 4];
                    draw2dtexturesIndices = new ushort[draw2dtexturesMAX * 4];
                }
                vertices = draw2dtexturesVertices;
                indices = draw2dtexturesIndices;
            }
            ushort i = 0;
            foreach (Draw2dData v in todraw)
            {
                RectangleF rect;
                if (v.inAtlasId == null)
                {
                    rect = new RectangleF(0, 0, 1, 1);
                }
                else
                {
                    rect = TextureAtlas.TextureCoords2d(v.inAtlasId.Value, d_Terrain.texturesPacked);
                }
                float x2 = v.x1 + v.width;
                float y2 = v.y1 + v.height;

                PointF[] pnts = new PointF[4] {
                    new PointF(x2, y2),
                    new PointF(x2,v.y1),
                    new PointF(v.x1,v.y1),
                    new PointF(v.x1,y2)};
                if (angle != 0)
                {
                    System.Drawing.Drawing2D.Matrix mx=new System.Drawing.Drawing2D.Matrix();
                    mx.RotateAt(angle, new PointF(v.x1+v.width/2,v.y1+v.height/2));
                    mx.TransformPoints(pnts);
                }

                vertices[i] = new VertexPositionTexture(pnts[0].X, pnts[0].Y, 0, rect.Right, rect.Bottom, v.color);
                vertices[i + 1] = new VertexPositionTexture(pnts[1].X, pnts[1].Y, 0, rect.Right, rect.Top, v.color);
                vertices[i + 2] = new VertexPositionTexture(pnts[2].X, pnts[2].Y, 0, rect.Left, rect.Top, v.color);
                vertices[i + 3] = new VertexPositionTexture(pnts[3].X, pnts[3].Y, 0, rect.Left, rect.Bottom, v.color);
                indices[i] = i;
                indices[i + 1] = (ushort)(i + 1);
                indices[i + 2] = (ushort)(i + 2);
                indices[i + 3] = (ushort)(i + 3);
                i += 4;
            }
            GL.EnableClientState(ArrayCap.TextureCoordArray);
            GL.EnableClientState(ArrayCap.VertexArray);
            GL.EnableClientState(ArrayCap.ColorArray);
            unsafe
            {
                fixed (VertexPositionTexture* p = vertices)
                {
                    GL.VertexPointer(3, VertexPointerType.Float, StrideOfVertices, (IntPtr)(0 + (byte*)p));
                    GL.TexCoordPointer(2, TexCoordPointerType.Float, StrideOfVertices, (IntPtr)(12 + (byte*)p));
                    GL.ColorPointer(4, ColorPointerType.UnsignedByte, StrideOfVertices, (IntPtr)(20 + (byte*)p));
                    GL.DrawElements(BeginMode.Quads, i, DrawElementsType.UnsignedShort, indices);
                }
            }
            GL.DisableClientState(ArrayCap.TextureCoordArray);
            GL.DisableClientState(ArrayCap.VertexArray);
            GL.DisableClientState(ArrayCap.ColorArray);

            GL.Enable(EnableCap.DepthTest);
            GL.PopAttrib();
        }
 public override void SetBoundingRect(System.Drawing.RectangleF bounds)
 {
     // this method hasn't been used yet
     switch (this.Shape)
     {
         case PathShape.Curve:
             throw new NotImplementedException();
         case PathShape.Ellipse:
             //m_path = new VectorPath();
             //m_path.AddEllipse(bounds);
             //break;
         case PathShape.Rectangle:
             //m_path = new VectorPath();
             //m_path.AddRectangle(bounds);
             //break;
         case PathShape.Freeform:
             RectangleF oldBounds = GetBoundingRect();
             SizeF oldSize = oldBounds.Size;
             SizeF newSize = bounds.Size;
             PointF oldCorner = oldBounds.Location;
             PointF newCorner = bounds.Location;
             System.Drawing.Drawing2D.Matrix m = new System.Drawing.Drawing2D.Matrix();
             m.Translate(-oldCorner.X, -oldCorner.Y);
             m.Scale(newSize.Width / oldSize.Width, newSize.Height / oldSize.Height);
             m.Translate(newCorner.X, newCorner.Y);
             m_path.Transform(m);
             break;
     }
 }
예제 #47
0
파일: D2dUtil.cs 프로젝트: Joxx0r/ATF
        /// <summary>
        /// Draws a horizontal chart scale</summary>
        /// <param name="g">The Direct2D graphics object</param>
        /// <param name="transform">Graph (world) to window's client (screen) transform</param>
        /// <param name="graphRect">Graph rectangle</param>
        /// <param name="top">Whether or not the scale should be aligned along the top of the rectangle</param>
        /// <param name="majorSpacing">Spacing, in pixels, between major tick marks</param>
        /// <param name="minimumGraphStep">Minimum spacing, in graph (world) space, between ticks.
        /// For example, 1.0 would limit ticks to being drawn on whole integers.</param>
        /// <param name="lineBrush">Scale line pen</param>
        /// <param name="textFormat">Text format</param>
        /// <param name="textBrush">Text brush</param>
        public static void DrawHorizontalScale(
            this D2dGraphics g,
            Matrix transform,
            RectangleF graphRect,
            bool top,
            int majorSpacing,
            float minimumGraphStep,
            D2dBrush lineBrush,
            D2dTextFormat textFormat,
            D2dBrush textBrush)
        {
            double xScale = transform.Elements[0];
            RectangleF clientRect = Transform(transform, graphRect);

            double tickEnd, majorTickStart, minorTickStart, textStart;

            if (top)
            {
                tickEnd = clientRect.Top + 1;
                majorTickStart = tickEnd + 12;
                minorTickStart = tickEnd + 6;
                textStart = tickEnd + 8;
            }
            else
            {
                tickEnd = clientRect.Bottom - 1;
                majorTickStart = tickEnd - 12;
                minorTickStart = tickEnd - 6;
                textStart = tickEnd - 19;
            }

            double min = Math.Min(graphRect.Left, graphRect.Right);
            double max = Math.Max(graphRect.Left, graphRect.Right);

            double tickAnchor = CalculateTickAnchor(min, max);
            double majorGraphStep = CalculateStep(
                min, max, Math.Abs(clientRect.Right - clientRect.Left), majorSpacing, minimumGraphStep);
            int numMinorTicks = CalculateNumMinorTicks(majorGraphStep, minimumGraphStep, 5);
            double cMinorStep = (majorGraphStep / numMinorTicks) * xScale;
            if (majorGraphStep > 0)
            {
                double offset = tickAnchor - min;
                offset = offset - MathUtil.Remainder(offset, majorGraphStep);

                // draw leading minor ticks
                double cmx;
                cmx = ((tickAnchor - (offset + majorGraphStep)) - min) * xScale + clientRect.Left + cMinorStep;
                for (int i = 0; i < numMinorTicks - 1 && cmx < clientRect.Right; i++)
                {
                    // cull minor ticks outside of the view
                    if (cmx > clientRect.Left)
                    {
                        g.DrawLine((float)cmx, (float)minorTickStart, (float)cmx, (float)tickEnd, lineBrush);
                    }
                    cmx += cMinorStep;
                }

                for (double x = tickAnchor - offset; x < max; x += majorGraphStep)
                {
                    double cx = (x - min) * xScale + clientRect.Left;
                    g.DrawLine((float)cx, (float)majorTickStart, (float)cx, (float)tickEnd, lineBrush);
                    string xString = String.Format("{0:G8}", Math.Round(x, 6));
                    SizeF textSize = g.MeasureText(xString, textFormat);
                    var textRect = new RectangleF(new PointF((float)cx + 1, (float)textStart), textSize);
                    g.DrawText(xString, textFormat, textRect, textBrush);

                    // draw minor ticks
                    cmx = cx + cMinorStep;
                    for (int i = 0; i < numMinorTicks - 1 && cmx < clientRect.Right; i++)
                    {
                        g.DrawLine((float)cmx, (float)minorTickStart, (float)cmx, (float)tickEnd, lineBrush);
                        cmx += cMinorStep;
                    }
                }
            }
        }
예제 #48
0
파일: MPF.cs 프로젝트: davinx/MediaPortal-2
    public static bool ConvertType(object value, Type targetType, out object result)
    {
      result = value;
      if (value == null)
        return true;
      if (value is string && targetType == typeof(Type))
      {
        string typeName = (string)value;
        Type type;
        if (!_objectClassRegistrations.TryGetValue(typeName, out type))
          type = Type.GetType(typeName);
        if (type != null)
        {
          result = type;
          return true;
        }
      }
      // Don't convert LateBoundValue (or superclass ValueWrapper) here... instances of
      // LateBoundValue must stay unchanged until some code part explicitly converts them!
      if (value is ResourceWrapper)
      {
        object resource = ((ResourceWrapper)value).Resource;
        if (TypeConverter.Convert(resource, targetType, out result))
        {
          if (ReferenceEquals(resource, result))
          {
            // Resource must be copied because setters and other controls most probably need a copy of the resource.
            // If we don't copy it, Setter is not able to check if we already return a copy because our input value differs
            // from the output value, even if we didn't do a copy here.
            result = MpfCopyManager.DeepCopyCutLVPs(result);
          }
          return true;
        }
      }
      if (value is string && targetType == typeof(FrameworkElement))
      {
        // It doesn't suffice to have an implicit data template declaration which returns a label for a string.
        // If you try to build a ResourceWrapper with a string and assign that ResourceWrapper to a Button's Content property
        // with a StaticResource, for example, the ResourceWrapper will be assigned directly without the data template being
        // applied. To make it sill work, we need this explicit type conversion here.
        result = new Label { Content = (string)value, Color = Color.White };
        return true;
      }
      if (targetType == typeof(Transform))
      {
        string v = value.ToString();
        string[] parts = v.Split(new[] { ',' });
        if (parts.Length == 6)
        {
          float[] f = new float[parts.Length];
          for (int i = 0; i < parts.Length; ++i)
          {
            object obj;
            TypeConverter.Convert(parts[i], typeof(double), out obj);
            f[i] = (float)obj;
          }
          System.Drawing.Drawing2D.Matrix matrix2D = new System.Drawing.Drawing2D.Matrix(f[0], f[1], f[2], f[3], f[4], f[5]);
          Static2dMatrix matrix = new Static2dMatrix();
          matrix.Set2DMatrix(matrix2D);
          result = matrix;
          return true;
        }
      }
      else if (targetType == typeof(Vector2))
      {
        result = Convert2Vector2(value.ToString());
        return true;
      }
      else if (targetType == typeof(Vector3))
      {
        result = Convert2Vector3(value.ToString());
        return true;
      }
      else if (targetType == typeof(Vector4))
      {
        result = Convert2Vector4(value.ToString());
        return true;
      }
      else if (targetType == typeof(Thickness))
      {
        Thickness t;
        float[] numberList = ParseFloatList(value.ToString());

        if (numberList.Length == 1)
        {
          t = new Thickness(numberList[0]);
        }
        else if (numberList.Length == 2)
        {
          t = new Thickness(numberList[0], numberList[1]);
        }
        else if (numberList.Length == 4)
        {
          t = new Thickness(numberList[0], numberList[1], numberList[2], numberList[3]);
        }
        else
        {
          throw new ArgumentException("Invalid # of parameters");
        }
        result = t;
        return true;
      }
      else if (targetType == typeof(Color))
      {
        Color color;
        if (ColorConverter.ConvertColor(value, out color))
        {
          result = color;
          return true;
        }
      }
      else if (targetType == typeof(Brush) && value is string || value is Color)
      {
        try
        {
          Color color;
          if (ColorConverter.ConvertColor(value, out color))
          {
            SolidColorBrush b = new SolidColorBrush
            {
              Color = color
            };
            result = b;
            return true;
          }
        }
        catch (Exception)
        {
          return false;
        }
      }
      else if (targetType == typeof(GridLength))
      {
        string text = value.ToString();
        if (text == "Auto")
          result = new GridLength(GridUnitType.Auto, 0.0);
        else if (text == "AutoStretch")
          result = new GridLength(GridUnitType.AutoStretch, 1.0);
        else if (text.IndexOf('*') >= 0)
        {
          int pos = text.IndexOf('*');
          text = text.Substring(0, pos);
          if (text.Length > 0)
          {
            object obj;
            TypeConverter.Convert(text, typeof(double), out obj);
            result = new GridLength(GridUnitType.Star, (double)obj);
          }
          else
            result = new GridLength(GridUnitType.Star, 1.0);
        }
        else
        {
          double v = double.Parse(text);
          result = new GridLength(GridUnitType.Pixel, v);
        }
        return true;
      }
      else if (targetType == typeof(string) && value is IResourceString)
      {
        result = ((IResourceString)value).Evaluate();
        return true;
      }
      else if (targetType.IsAssignableFrom(typeof(IExecutableCommand)) && value is ICommand)
      {
        result = new CommandBridge((ICommand)value);
        return true;
      }
      else if (targetType == typeof(Key) && value is string)
      {
        string str = (string)value;
        // Try a special key
        result = Key.GetSpecialKeyByName(str);
        if (result == null)
          if (str.Length != 1)
            throw new ArgumentException(string.Format("Cannot convert '{0}' to type Key", str));
          else
            result = new Key(str[0]);
        return true;
      }
      else if (targetType == typeof(string) && value is IEnumerable)
      {
        result = StringUtils.Join(", ", (IEnumerable)value);
        return true;
      }
      result = value;
      return false;
    }
예제 #49
0
 public PDFTransformationMatrix()
 {
     _matrix = new System.Drawing.Drawing2D.Matrix();
     _matrix.Reset();
 }
예제 #50
0
        public static SharpMap.Map InitializeMap(float angle)
        {
            //Initialize a new map of size 'imagesize'
            SharpMap.Map map = new SharpMap.Map();

            //Set up the countries layer
            SharpMap.Layers.VectorLayer layCountries = new SharpMap.Layers.VectorLayer("Countries");

            //Set the datasource to a shapefile in the App_data folder
            layCountries.DataSource = new SharpMap.Data.Providers.SpatiaLite(
                DataSource, "countries", "geom", "PK_UID");

            //Set fill-style to green
            layCountries.Style.Fill = new System.Drawing.SolidBrush(System.Drawing.Color.Green);
            //Set the polygons to have a black outline
            layCountries.Style.Outline = System.Drawing.Pens.Black;
            layCountries.Style.EnableOutline = true;

            //Set up a river layer
            SharpMap.Layers.VectorLayer layRivers = new SharpMap.Layers.VectorLayer("Rivers");
            //Set the datasource to a shapefile in the App_data folder
            layRivers.DataSource = new SharpMap.Data.Providers.SpatiaLite(
                DataSource, "rivers", "geom", "PK_UID");
            //Define a blue 3px wide pen
            layRivers.Style.Line = new System.Drawing.Pen(System.Drawing.Color.LightBlue, 2);
            layRivers.Style.Line.CompoundArray = new[] { 0.2f, 0.8f };
            layRivers.Style.Outline = new System.Drawing.Pen(System.Drawing.Color.DarkBlue, 3);
            layRivers.Style.EnableOutline = true;

            //Set up a cities layer
            SharpMap.Layers.VectorLayer layCities = new SharpMap.Layers.VectorLayer("Cities");
            //Set the datasource to the spatialite table
            layCities.DataSource = new SharpMap.Data.Providers.SpatiaLite(
                DataSource, "cities", "geom", "PK_UID");
            layCities.Style.SymbolScale = 0.8f;
            layCities.MaxVisible = 40;

            //Set up a country label layer
            SharpMap.Layers.LabelLayer layLabel = new SharpMap.Layers.LabelLayer("Country labels") 
            {
                DataSource = layCountries.DataSource,
                LabelColumn = "NAME",
                MultipartGeometryBehaviour = SharpMap.Layers.LabelLayer.MultipartGeometryBehaviourEnum.Largest,
                LabelFilter = SharpMap.Rendering.LabelCollisionDetection.ThoroughCollisionDetection,
                PriorityColumn = "POPDENS",
                Style = new SharpMap.Styles.LabelStyle
                {
                    ForeColor = System.Drawing.Color.White,
                    Font = new System.Drawing.Font(System.Drawing.FontFamily.GenericSerif, 12),
                    BackColor = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(128, 255, 0, 0)),
                    HorizontalAlignment = SharpMap.Styles.LabelStyle.HorizontalAlignmentEnum.Center,
                    MaxVisible = 90,
                    MinVisible = 30,
                    CollisionDetection = true
                }
            };

            //Set up a city label layer
            SharpMap.Layers.LabelLayer layCityLabel = new SharpMap.Layers.LabelLayer("City labels")
            {
                DataSource = layCities.DataSource,
                LabelColumn = "name",
                PriorityColumn = "population",
                PriorityDelegate = delegate(SharpMap.Data.FeatureDataRow fdr) 
                { 
                    System.Int32 retVal = 10000000 * ( (System.String)fdr["capital"] == "Y" ? 1 : 0 );
                    return  retVal + System.Convert.ToInt32(fdr["population"]);
                },
                TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias,
                SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias,
                LabelFilter = SharpMap.Rendering.LabelCollisionDetection.ThoroughCollisionDetection,
                Style = new SharpMap.Styles.LabelStyle
                {
                    ForeColor = System.Drawing.Color.Black,
                    Font = new System.Drawing.Font(System.Drawing.FontFamily.GenericSerif, 11),
                    MaxVisible = layLabel.MinVisible,
                    HorizontalAlignment = SharpMap.Styles.LabelStyle.HorizontalAlignmentEnum.Left,
                    VerticalAlignment = SharpMap.Styles.LabelStyle.VerticalAlignmentEnum.Bottom,
                    Offset = new System.Drawing.PointF(3, 3),
                    Halo = new System.Drawing.Pen(System.Drawing.Color.Yellow, 2),
                    CollisionDetection = true
                }
            };

            var layRiverLabels = new SharpMap.Layers.LabelLayer("RiverLabels");
            layRiverLabels.DataSource = layRivers.DataSource;
            layRiverLabels.LabelColumn = "Name";
            layRiverLabels.PriorityDelegate = GetRiverLength;
            layRiverLabels.Style = new SharpMap.Styles.LabelStyle
                                       {
                                           Font = new System.Drawing.Font("Arial", 10, System.Drawing.FontStyle.Bold),
                                           Halo = new System.Drawing.Pen(System.Drawing.Color.Azure, 2),
                                           ForeColor = System.Drawing.Color.DarkCyan,
                                           IgnoreLength = true,
                                           Enabled = true,
                                           CollisionDetection = true,
                                          
                                       };
            layRiverLabels.LabelFilter = SharpMap.Rendering.LabelCollisionDetection.ThoroughCollisionDetection;

            //Add the layers to the map object.
            //The order we add them in are the order they are drawn, so we add the rivers last to put them on top
            map.Layers.Add(layCountries);
            map.Layers.Add(layRivers);
            map.Layers.Add(layCities);
            map.Layers.Add(layRiverLabels);
            map.Layers.Add(layLabel);
            map.Layers.Add(layCityLabel);

            //limit the zoom to 360 degrees width
            map.MaximumZoom = 360;
            map.BackColor = System.Drawing.Color.LightBlue;

            map.ZoomToExtents(); // = 360;
            //map.Center = new SharpMap.Geometries.Point(0, 0);
            var mat = new System.Drawing.Drawing2D.Matrix();
            mat.RotateAt(angle, map.WorldToImage(map.Center));
            map.MapTransform = mat;
            return map;

        }
        // draw Elipse--------------------------------------------------------------------------------------------------------------
        private void OnTimerDrwElipse()
        {
            Graphics g = bufferedGraphics.Graphics;

            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
            int radius = mSensitivityOfTest / 2;

            // for circle we need a 360' angle
            if (angle > 359)
            {
                for (int i = 0; i <= 359; i++)
                {
                    System.Drawing.Drawing2D.Matrix matrix2 = new System.Drawing.Drawing2D.Matrix();
                    matrix2.Rotate(i, System.Drawing.Drawing2D.MatrixOrder.Append);
                    matrix2.Translate(this.ClientSize.Width / 2,
                                      this.ClientSize.Height / 2, System.Drawing.Drawing2D.MatrixOrder.Append);

                    g.Transform = matrix2;
                    g.FillEllipse(Brushes.Yellow, -300, -300, 10, 10);

                    if (!goExit)
                    {
                        bufferedGraphics.Render(Graphics.FromHwnd(this.Handle));
                    }
                }


                angle = 0;
                foreach (Point p in gazePointListForElips)
                {
                    g.FillEllipse(Brushes.DeepSkyBlue, p.X - this.ClientSize.Width / 2 - 5, p.Y - this.ClientSize.Height / 2 - 5, 10, 10);
                    if (!goExit)
                    {
                        bufferedGraphics.Render(Graphics.FromHwnd(this.Handle));
                    }
                    angle++;
                }


                // Find the True and False gaze points according to shapes coordinate

                /* for (int i = 0; i < gazePointListForElips.Count; i++)
                 * {
                 *   int gazeX = gazePointListForElips[i].X;
                 *   int gazeY = gazePointListForElips[i].Y;
                 *
                 *   int shapeX = shapPointListForElips[i].X;
                 *   int shapeY = shapPointListForElips[i].Y;
                 *
                 *   g.FillEllipse(Brushes.Blue, gazeX - this.ClientSize.Width / 2 - 5-radius, gazeY - this.ClientSize.Height / 2 - 5- radius, 10, 10);
                 *   if (!goExit)
                 *       bufferedGraphics.Render(Graphics.FromHwnd(this.Handle));
                 *
                 *  /* //true gaze points
                 *   if (Math.Abs(gazeX - shapeX) <= mSensitivityOfTest && Math.Abs(gazeY - shapeY) <= mSensitivityOfTest)
                 *   {
                 *       ElipsTruePoints++;
                 *       g.FillEllipse(Brushes.Green, gazeX - this.ClientSize.Width / 2 - 5, gazeY - this.ClientSize.Height / 2 - 5, 10, 10);
                 *       if (!goExit)
                 *           bufferedGraphics.Render(Graphics.FromHwnd(this.Handle));
                 *   }
                 *
                 *   //false gaze points
                 *   else
                 *   {
                 *       ElipsFalsePoints++;
                 *       g.FillEllipse(Brushes.Red, gazeX - this.ClientSize.Width / 2 - 5, gazeY - this.ClientSize.Height / 2 - 5, 10, 10);
                 *       if (!goExit)
                 *           bufferedGraphics.Render(Graphics.FromHwnd(this.Handle));
                 *   }
                 *
                 * }*/
                timer.Stop();
                //Save the Image
                finishTesting = true;
                saveTheTestingImage("Elipse-Test", gazePointListForElips, shapPointListForElips);
                g.Clear(Color.Black);
                doingElipse = false;

                // finishTesting = true;
            }

            // g.Clear(Color.Black);
            if (angle <= 359 && angle != 0)
            {
                /*
                 * X := originX + cos(angle)*radius;
                 * Y := originY + sin(angle)*radius;
                 * (X, Y) is the center of your circle. radius is its radius
                 * */

                int x = (int)(this.Width / 2 + Math.Cos(angle) * 300) - this.ClientSize.Width / 2;
                int y = (int)(this.Height / 2 + Math.Sin(angle) * 300) - this.ClientSize.Height / 2;

                System.Drawing.Drawing2D.Matrix matrix = new System.Drawing.Drawing2D.Matrix();
                matrix.Rotate(angle, System.Drawing.Drawing2D.MatrixOrder.Append);
                matrix.Translate(this.ClientSize.Width / 2,
                                 this.ClientSize.Height / 2, System.Drawing.Drawing2D.MatrixOrder.Append);

                g.Transform = matrix;
                g.FillEllipse(Brushes.Red, -300, -300, mSensitivityOfTest, mSensitivityOfTest);
                g.FillEllipse(Brushes.Black, -300 + radius - 3, -300 + radius - 3, 6, 6);

                //adding to list

                gazePointListForElips.Add(getGazePoint());
                shapPointListForElips.Add(new Point(x, y));

                if (!goExit)
                {
                    bufferedGraphics.Render(Graphics.FromHwnd(this.Handle));
                }
                g.Clear(Color.Black);
            }
            angle++;
            //clearScreen
            //this.Close();
        }
예제 #52
0
        /// <summary>
        /// Draw page and its children
        /// </summary>
        /// <param name="gc"></param>
        /// <param name="clipRect"></param>
        public void Draw(Graphics gc, Rectangle clipRect)
        {
            System.Drawing.Drawing2D.Matrix finalMatrix = new System.Drawing.Drawing2D.Matrix();
            finalMatrix = this.drawMatrix.Clone();
            finalMatrix.Multiply(this.ViewMatrix, System.Drawing.Drawing2D.MatrixOrder.Append);

            gc.Transform = finalMatrix;

            // draw fill color
            using (SolidBrush brush = new SolidBrush(fillColor))
            {
                gc.FillRectangle(brush, 0, 0, (float)this.WidthInPixels, (float)this.HeightInPixels);
            }

            // draw background image
            if (pictureForDisplay != null)
            {
                gc.DrawImage(pictureForDisplay, 0, 0, (float)this.WidthInPixels, (float)this.HeightInPixels);
            }

            this.LastDrawMatrix = finalMatrix;

            EditorController.Instance.Grid.Draw(gc);

            foreach(EditorItem item in Children)
            {
                item.Draw(this.ViewMatrix, gc, clipRect);
            }

            // draw item commands
            foreach (EditorItem child in Children)
            {
                child.DrawCommands((float)this.ZoomLevel / 100, gc);
            }
        }
        private void DrawFillPattern(Graphics gfx, double width, double height)
        {
            // verify fill pattern
            var fillPattern = FillPattern;

            if (fillPattern == null)
            {
                return;
            }

            // determine drawing scale
            float matrixScale;

            if (fillPattern.Target == FillPatternTarget.Model)
            {
                matrixScale = _scale;
            }
            else
            {
                matrixScale = _scale * 10;
            }

            // prepare pen
            var pen = new Pen(System.Drawing.Color.Black)
            {
                Width = 1f / matrixScale
            };

            try {
                // setup rectangle and center
                var viewRect = new Rectangle(0, 0, (int)width, (int)height);
                var centerX  = (viewRect.Left + viewRect.Left + viewRect.Width) / 2;
                var centerY  = (viewRect.Top + viewRect.Top + viewRect.Height) / 2;

                gfx.ResetTransform();

                // draw each fill grid
                foreach (var fillGrid in fillPattern.GetFillGrids())
                {
                    // radian to degree: inline math is faster
                    var degreeAngle = (float)(fillGrid.Angle * 180 / Math.PI);

                    // setup pen dash
                    float dashLength = 1;
                    var   segments   = fillGrid.GetSegments();
                    if (segments.Count > 0)
                    {
                        pen.DashPattern = segments.Select(Convert.ToSingle).ToArray();
                        dashLength      = pen.DashPattern.Sum();
                    }

                    gfx.ResetTransform();
                    // determine offset and rotation
                    var offset       = (-10) * dashLength;
                    var rotateMatrix = new Matrix();
                    rotateMatrix.Rotate(degreeAngle);

                    var matrix = new Matrix(1, 0, 0, -1, centerX, centerY);
                    matrix.Scale(matrixScale, matrixScale);
                    matrix.Translate((float)fillGrid.Origin.U, (float)fillGrid.Origin.V);

                    // make a copy for backward move
                    var backMatrix = matrix.Clone();

                    matrix.Multiply(rotateMatrix);
                    matrix.Translate(offset, 0);

                    backMatrix.Multiply(rotateMatrix);
                    backMatrix.Translate(offset, 0);

                    int    safety     = 250;
                    double alternator = 0;

                    // draw moving forward
                    while (IntersectsWith(matrix, viewRect) && safety > 0)
                    {
                        gfx.Transform = matrix;
                        gfx.DrawLine(pen, 0, 0, _length, 0);

                        matrix.Translate((float)fillGrid.Shift, (float)fillGrid.Offset);

                        alternator += fillGrid.Shift;
                        if (Math.Abs(alternator) > Math.Abs(offset))
                        {
                            matrix.Translate(offset, 0);
                            alternator = 0d;
                        }

                        --safety;
                    }

                    // draw moving backward
                    safety     = 250;
                    alternator = 0;
                    while (IntersectsWith(backMatrix, viewRect) && safety > 0)
                    {
                        gfx.Transform = backMatrix;
                        gfx.DrawLine(pen, 0, 0, _length, 0);

                        backMatrix.Translate(-(float)fillGrid.Shift, -(float)fillGrid.Offset);

                        alternator += fillGrid.Shift;
                        if (Math.Abs(alternator) > Math.Abs(offset))
                        {
                            backMatrix.Translate(offset, 0);
                            alternator = 0d;
                        }

                        --safety;
                    }
                }
            }
            catch (Exception ex) {
                logger.Debug(ex.ToString());
            }
        }
예제 #54
0
        public bool Render(DisplayInformation dpInfo, LayoutManager lm, bool isDesktopMode)
        {
            if( m_outputPath == string.Empty)
                return false;

            Rectangle wallRect;

            if (isDesktopMode)
            {
                wallRect = dpInfo.DesktopBounds;
            }
            else
            {
                wallRect = dpInfo.Primary.Bounds;
                wallRect.X = 0;
                wallRect.Y = 0;
            }

            //  Create the bitmap representing the wallpaper
            Bitmap bmp = new Bitmap(wallRect.Width, wallRect.Height);

            Graphics e = Graphics.FromImage(bmp);

            e.FillRectangle(Brushes.Black, 0, 0, wallRect.Width, wallRect.Height);

            foreach(KeyValuePair<int, LayoutCanvas> kvp in lm)
            {
                LayoutCanvas canvas = kvp.Value;
                Screen screen = dpInfo.Screens[kvp.Key];

                //  Get X and Y coordinates of screen in IMAGE coordinates (taking into account
                //  the shifts required to display the image properly)
                int x = (screen.X < 0) ? wallRect.Width + screen.X : screen.X;
                int y = (screen.Y < 0) ? -screen.Y : screen.Y;

                Rectangle scrBounds = new Rectangle(x, y, screen.Width, screen.Height);

                //  Fill screen background
                if (screen.Y >= 0)
                {
                    e.FillRectangle(new SolidBrush(canvas.BackgroundColour), scrBounds);
                }
                else
                {
                    Rectangle scrTop = new Rectangle(x, wallRect.Height - y, scrBounds.Width, -wallRect.Y);
                    Rectangle scrBtm = new Rectangle(x, -wallRect.Y - y, scrBounds.Width, scrBounds.Height + wallRect.Y);

                    Brush brush = new SolidBrush(canvas.BackgroundColour);

                    e.FillRectangle(brush, scrTop);
                    e.FillRectangle(brush, scrBtm);
                }

                //  Sort based on ZIndex
                LayoutObject[] clone = new LayoutObject[canvas.Count];
                canvas.CopyTo(clone);
                BubbleSort(clone);

                for( int i = 0; i < clone.Length; i++)
                {
                    LayoutObject lo = clone[i];

                    string trueSource = string.Empty;

                    if (canvas.IsShuffleEnabled)
                    {
                        trueSource = FileRandomizer.GetRandomFile(
                            Path.GetDirectoryName(lo.Source));
                    }
                    else
                    {
                        trueSource = lo.Source;
                    }

                    Rectangle loBounds = new Rectangle(lo.X + x, lo.Y + y, lo.ActualWidth, lo.ActualHeight);

                    if (scrBounds.IntersectsWith(loBounds))
                    {
                        //  Get intersecting region
                        Rectangle intRect = Rectangle.Intersect(scrBounds, loBounds);

                        //  Resized image
                        Bitmap bmpImage;

                        if (lo.IsFlippedX || lo.IsFlippedY)
                        {
                            bmpImage = new Bitmap(loBounds.Width, loBounds.Height);
                            Graphics gb = Graphics.FromImage(bmpImage);

                            System.Drawing.Drawing2D.Matrix m = new System.Drawing.Drawing2D.Matrix();

                            m.Scale((lo.IsFlippedX) ? -1 : 1, (lo.IsFlippedY) ? -1 : 1);

                            if(lo.IsFlippedX)
                                m.Translate((float)-loBounds.Width + 1, 0);

                            if (lo.IsFlippedY)
                                m.Translate(0, (float)-loBounds.Height + 1);

                            gb.Transform = m;
                            gb.DrawImage(Image.FromFile(trueSource), new Rectangle(0, 0, loBounds.Width, loBounds.Height));
                            gb.Flush();
                            gb.Dispose();
                            gb = null;
                        }
                        else
                        {
                            bmpImage= new Bitmap(Image.FromFile(trueSource), loBounds.Size);
                        }

                        //  The destination rectangle has the same width and height as the intersection rect
                        //  but we must update the coordinates
                        Rectangle destRect = intRect;

                        //  Get the image's x and y coordinates relative to the screen position
                        int ix = loBounds.X - x;
                        int iy = loBounds.Y - y;

                        //  Offset the in image coords with the image coords
                        destRect.X = (ix < 0) ? x : (x + ix);
                        destRect.Y = (iy < 0) ? y : (y + iy);

                        //  Calculate the source rectangle
                        Rectangle srcRect = intRect;

                        srcRect.X = 0;
                        srcRect.Y = 0;

                        //  If the image has negative coordinates, ie, it starts off the screen, we must
                        //  set the x to equal the portion into the image thats on the screen
                        if (ix < 0) srcRect.X = (-1 * ix);
                        if (iy < 0) srcRect.Y = (-1 * iy);

                        if (screen.Y >= 0)
                        {
                            e.DrawImage(bmpImage, destRect, srcRect, GraphicsUnit.Pixel);
                        }
                        else
                        {
                            /*

                            +----------------+
                            |xxxxxxxxxxxxxxxx|
                            |xxxxxxxxxxxxxxxx|
                            |                +----------------+
                            |                |                |
                            +----------------+                |
                                             |                |
                                             +----------------+

                            */
                            destRect.Offset(0, screen.Y);

                            Rectangle scrTop = new Rectangle(x, y + wallRect.Y, scrBounds.Width, -wallRect.Y);
                            Rectangle scrBtm = new Rectangle(x, y, scrBounds.Width, scrBounds.Height + wallRect.Y);

                            Rectangle destRectTop = Rectangle.Intersect(scrTop, destRect);
                            Rectangle destRectBtm = Rectangle.Intersect(scrBtm, destRect);

                            //  destRectBtm -> Paints ontop
                            //  destRectTop -> Paints on bottom

                            destRectTop.Y = destRect.Y + (wallRect.Height - y);
                            destRectBtm.Y = -wallRect.Y - y;

                            Rectangle srcRectTop = new Rectangle(srcRect.X, srcRect.Y, destRectTop.Width, destRectTop.Height);
                            Rectangle srcRectBtm = new Rectangle(srcRect.X, srcRect.Y + srcRectTop.Height, destRectBtm.Width, destRectBtm.Height);

                            e.DrawImage(bmpImage, destRectTop, srcRectTop, GraphicsUnit.Pixel);
                            e.DrawImage(bmpImage, destRectBtm, srcRectBtm, GraphicsUnit.Pixel);
                        }

                        bmpImage.Dispose();
                        bmpImage = null;
                    }
                }
            }

            e.Flush(System.Drawing.Drawing2D.FlushIntention.Flush);

            try
            {
                bmp.Save(m_outputPath, m_format);
            }
            catch(Exception)
            {
                e.Dispose();
                e = null;
                bmp.Dispose();
                bmp = null;

                return false;
            }

            e.Dispose();
            e = null;
            bmp.Dispose();
            bmp = null;

            GC.Collect();
            return true;
        }
        private void DrawFillPattern(Graphics g)
        {
            Stopwatch sw = Stopwatch.StartNew();
            float     matrixScale;
            var       fillPattern = FillPattern;

            if (fillPattern == null)
            {
                return;
            }

            if (fillPattern.Target == FillPatternTarget.Model)
            {
                matrixScale = Scale;
            }
            else
            {
                matrixScale = Scale * 10;
            }

            try
            {
                var width
                    = (ActualWidth == 0 ? Width : ActualWidth) == 0
            ? 100
            : (ActualWidth == 0 ? Width : ActualWidth);

                if (double.IsNaN(width))
                {
                    width = 100;
                }

                var height
                    = (ActualHeight == 0 ? Height : ActualHeight) == 0
            ? 30
            : (ActualHeight == 0 ? Height : ActualHeight);

                if (double.IsNaN(height))
                {
                    height = 30;
                }

                var viewRect = new Rectangle(
                    0, 0, (int)width, (int)height);

                var centerX = (viewRect.Left
                               + viewRect.Left + viewRect.Width) / 2;

                var centerY = (viewRect.Top
                               + viewRect.Top + viewRect.Height) / 2;

                g.TranslateTransform(centerX, centerY);

                var rectF = new Rectangle(-1, -1, 2, 2);
                g.FillRectangle(Brushes.Blue, rectF); //draw a small rectangle in the center of the image

                g.ResetTransform();

                var fillGrids = fillPattern.GetFillGrids();

                Debug.Print(new string( '-', 100 ));
                Debug.Print("FilPattern name: {0}", fillPattern.Name);
                if (fillPattern.Target == FillPatternTarget.Model)
                {
                    Debug.Print("FillPattern type: Model");
                }
                else
                {
                    Debug.Print("FillPattern type: Drafting");
                }
                Debug.Print("Matrix scale: {0}", matrixScale);
                Debug.Print("Grids count: {0}", fillGrids.Count);
                Debug.Print("Len\\Area: {0}", fillPattern.LengthPerArea);
                Debug.Print("Lines\\Len: {0}", fillPattern.LinesPerLength);
                Debug.Print("Strokes\\Area: {0}", fillPattern.StrokesPerArea);

                foreach (var fillGrid in fillGrids)
                {
                    var degreeAngle = (float)RadianToGradus(fillGrid.Angle);
                    Debug.Print(new string( '-', 50 ));
                    Debug.Print("Origin: U:{0} V:{1}",
                                fillGrid.Origin.U, fillGrid.Origin.V);
                    Debug.Print("Offset: {0}", fillGrid.Offset);
                    Debug.Print("Angle: {0}", degreeAngle);
                    Debug.Print("Shift: {0}", fillGrid.Shift);

                    var pen = new Pen(System.Drawing.Color.Black)
                    {
                        Width = 1f / matrixScale
                    };

                    float dashLength = 1;
                    var   segments   = fillGrid.GetSegments();

                    if (segments.Count > 0)
                    {
                        pen.DashPattern = segments
                                          .Select(s => Math.Max(float.Epsilon, Convert.ToSingle(s)))
                                          .ToArray();

                        Debug.Print("\tSegments:");
                        foreach (var segment in segments)
                        {
                            Debug.Print("\t\t{0}", segment);
                        }
                        dashLength = pen.DashPattern.Sum();
                    }
                    g.ResetTransform();
                    var rotateMatrix = new Matrix();
                    rotateMatrix.Rotate(degreeAngle);
                    var matrix = new Matrix(
                        1, 0, 0, -1, centerX, centerY); //-1 reflects about x-axis
                    matrix.Scale(matrixScale, matrixScale);
                    matrix.Translate((float)fillGrid.Origin.U,
                                     (float)fillGrid.Origin.V);
                    var backMatrix = matrix.Clone();
                    backMatrix.Multiply(rotateMatrix);
                    matrix.Multiply(rotateMatrix);

                    var offset = (-10) * dashLength;
                    matrix.Translate(offset, 0);
                    backMatrix.Translate(offset, 0);
                    Debug.Print("Offset: {0}", offset);


                    bool   moving_forward = true;
                    bool   moving_back    = true;
                    int    safety         = 500;
                    double alternator     = 0;
                    while (moving_forward || moving_back) // draw segments shifting and offsetting each time
                    {
                        Debug.Write("*");
                        var rectF1 = new RectangleF(
                            -2 / matrixScale, -2 / matrixScale,
                            4 / matrixScale, 4 / matrixScale);

                        if (moving_forward && LineIntersectsRect(
                                matrix, viewRect))
                        {
                            g.Transform = matrix;
                            g.DrawLine(pen, new PointF(0, 0),
                                       new PointF(LENGTH, 0));
                        }
                        else
                        {
                            moving_forward = false;
                            Debug.Print("\n----> Matrix does not intersect view");
                        }

                        if (moving_back && LineIntersectsRect(
                                backMatrix, viewRect))
                        {
                            g.Transform = backMatrix;
                            g.DrawLine(pen, new PointF(0, 0),
                                       new PointF(LENGTH, 0));
                        }
                        else
                        {
                            moving_back = false;
                            Debug.Print("\n----> Back matrix does not intersect view");
                        }

                        if (safety == 0)
                        {
                            Debug.Print("\n--------> Safety limit exceeded");
                            break;
                        }
                        else
                        {
                            --safety;
                        }

                        matrix.Translate((float)fillGrid.Shift,
                                         (float)fillGrid.Offset);
                        backMatrix.Translate(-(float)fillGrid.Shift,
                                             -(float)fillGrid.Offset);

                        alternator += fillGrid.Shift;
                        if (Math.Abs(alternator) > Math.Abs(offset))
                        {
                            Debug.Print("\n----> Alternating");
                            matrix.Translate(offset, 0);
                            backMatrix.Translate(offset, 0);
                            alternator = 0d;
                        }
                    }
                }
                sw.Stop();
                g.ResetTransform();

#if DEBUG
                g.DrawString(string.Format(
                                 "{0} ms", sw.ElapsedMilliseconds),
                             System.Drawing.SystemFonts.DefaultFont,
                             Brushes.Red, 0, 0);
#endif

                Debug.Print(new string( '-', 50 ));

                Pen p = new Pen(System.Drawing.Color.Black);
                p.Width = 1f / matrixScale;
                Debug.Print("Finished");
            }
            catch (Exception ex)
            {
                Debug.Print(ex.ToString());
            }
        }
        /// <summary>
        /// On Paint only paints the specified clip rectangle, but paints
        /// it from the page buffer.
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPaint(PaintEventArgs e)
        {

            Rectangle clip = e.ClipRectangle;
            if (clip.IsEmpty) clip = ClientRectangle;
            if (IsInitialized == false || _buffer == null)
            {
                Initialize(); // redraw the entire page buffer if necessary
            }

            Bitmap buffer = new Bitmap(clip.Width, clip.Height);
            Graphics g = Graphics.FromImage(buffer);
            System.Drawing.Drawing2D.Matrix mat = new System.Drawing.Drawing2D.Matrix();
            mat.Translate(-clip.X, -clip.Y); // draw in "client" coordinates
            g.Transform = mat;
            
            OnDraw(new PaintEventArgs(g, clip)); // draw content to the small temporary buffer.

            g.Dispose();
            e.Graphics.DrawImage(buffer, clip); // draw from our small, temporary buffer to the screen
            buffer.Dispose();
        }
예제 #57
0
        public Bitmap MakeGraph(float _xmin, float _xmax, float _ymin, float _ymax)
        {
            //The bounds to draw.
            xmin = _xmin;
            xmax = _xmax;
            ymin = _ymin;
            ymax = _ymax;

            // Make the Bitmap.
            gr = Graphics.FromImage(bitmapFunction);
            gr.Clear(Color.Transparent);
            gr.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

            //Transform the graphics object to cartesian coordinates
            float fdx = wid * -(xmin / (xmax - xmin));
            float fdy = hgt * -(ymax / (ymin - ymax));

            gr.TranslateTransform(fdx, fdy);

            float sx = Convert.ToSingle(wid) / Math.Abs(xmax - xmin);
            float sy = Convert.ToSingle(hgt) / Math.Abs(ymax - ymin);

            gr.ScaleTransform(sx, -sy);

            // Draw the graph.
            using (Pen graph_pen = new Pen(Color.Blue, 0), grid_pen = new Pen(Color.LightGray, 0))
            {
                for (int x = (int)xmin; x <= xmax; x++)
                {
                    //Draw Grid
                    gr.DrawLine(grid_pen, x, ymin, x, ymax);
                    //Draw AxesSeperation
                    gr.DrawLine(graph_pen, x, -0.1f, x, 0.1f);
                }
                for (int y = (int)ymin; y <= ymax; y++)
                {
                    //Draw Grid
                    gr.DrawLine(grid_pen, xmin, y, xmax, y);
                    //Draw AxesSeperation
                    gr.DrawLine(graph_pen, -0.1f, y, 0.1f, y);
                }

                //Draw the axes.
                gr.DrawLine(graph_pen, xmin, 0, xmax, 0);
                gr.DrawLine(graph_pen, 0, ymin, 0, ymax);

                graph_pen.Color = Color.Red;

                //See how big 1 pixel is horizontally.
                System.Drawing.Drawing2D.Matrix inverse = gr.Transform;
                inverse.Invert();
                PointF[] pixel_pts =
                {
                    new PointF(0, 0),
                    new PointF(1, 0)
                };
                inverse.TransformPoints(pixel_pts);
                float dx = pixel_pts[1].X - pixel_pts[0].X;
                dx /= 4;

                //Draw Function
                //Loop over every function in DataGridView
                for (int i = 0; i < dataGridView.RowCount - 1; i++)
                {
                    if (dataGridView.Rows[i].Selected == true)
                    {
                        float y;
                        //Loop over x values to generate points.
                        for (float x = xmin; x <= xmax; x += dx)
                        {
                            //Get the next point.
                            y = function(x, i);

                            if (!Single.IsNaN(y) && !Single.IsInfinity(y) && !(y > 100000))
                            {
                                //Only add points that are visible
                                if (y < ymax + 0.2 && ymin - 0.2 < y)
                                {
                                    if (function(x - dx, i) > ymax || function(x - dx, i) < ymin)
                                    {
                                        pointsFunction.Add(new PointF(x - dx, function(x - dx, i)));
                                    }

                                    pointsFunction.Add(new PointF(x, y));

                                    if (function(x + dx, i) > ymax || function(x + dx, i) < ymin)
                                    {
                                        pointsFunction.Add(new PointF(x + dx, function(x + dx, i)));
                                    }
                                }
                            }
                        }

                        if (pointsFunction.Count != 0)
                        {
                            try
                            {
                                gr.DrawLines(graph_pen, pointsFunction.ToArray());
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show(e.ToString(), e.Message);
                            }
                        }
                        pointsFunction.Clear();
                    }
                }
            }

            controller.UpdateFunctionTextBox(xmin, xmax, ymin, ymax);

            //return the result.
            return(DrawVisualization());
        }
예제 #58
0
파일: D2dUtil.cs 프로젝트: Joxx0r/ATF
 /// <summary>
 /// Transforms rectangle</summary>
 /// <param name="matrix">Matrix representing transform</param>
 /// <param name="r">Rectangle</param>
 /// <returns>Transformed rectangle</returns>
 public static RectangleF Transform(Matrix matrix, RectangleF r)
 {
     s_tempPtsF[0] = new PointF(r.Left, r.Top);
     s_tempPtsF[1] = new PointF(r.Right, r.Bottom);
     matrix.TransformPoints(s_tempPtsF);
     return MakeRectangle(s_tempPtsF[0], s_tempPtsF[1]);
 }
예제 #59
0
 protected PDFTransformationMatrix(System.Drawing.Drawing2D.Matrix innerMatrix)
 {
     this._matrix = innerMatrix;
 }
예제 #60
-1
        public static SharpMap.Map InitializeMap(float angle)
        {
            using (var ofn = new System.Windows.Forms.OpenFileDialog())
            {
                ofn.Filter = "All files|*.*";
                ofn.FilterIndex = 0;

                if (ofn.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    var m = new SharpMap.Map();
                    var l = new SharpMap.Layers.GdiImageLayer(ofn.FileName);
                    m.Layers.Add(l);

                    m.ZoomToExtents();

                    var mat = new System.Drawing.Drawing2D.Matrix();
                    mat.RotateAt(angle, m.WorldToImage(m.Center));
                    m.MapTransform = mat;
                    m.MaximumExtents = m.GetExtents();
                    m.EnforceMaximumExtents = true;
                    return m;
                }
            }
            return null;

        }