Esempio n. 1
0
        private void _paintMAP(Graphics g)
        {
            _ttC.Clear();
            _ttC.Active = false;

            if (_screenRad < _worldScreenRadius && _screenRad < _worldScreenRadius)
            {
                g.FillRectangle(_seaBrush, 0, 0, pictureBox1.Width, pictureBox1.Height);
            }
            else
            {
                g.FillEllipse(_seaBrush, _scX - _worldScreenRadius, _scY - _worldScreenRadius, _worldScreenRadius * 2, _worldScreenRadius * 2);
            }

            // settle for fast and dirty draw!
            foreach (WSMCountry cDef in _rwmap.Collection)
            {
                Region reg = _internalBorderRegion(cDef);
                // fill
                if (reg != null)
                {
                    g.FillRegion(cDef.Brush, reg);
                    _ttC.Add(reg, cDef.Name, cDef);
                }
                _drawCountryOutline(g, cDef, Pens.Gold);
            }

            if (cities != null)
            {
                int maxX         = pictureBox1.Width + 20;
                int maxY         = pictureBox1.Height + 20;
                int nCitiesDrawn = 0;
                g.TranslateTransform(-1, -1);
                foreach (NamedCoordinate nC in cities.Collection)
                {
                    if (double.IsNaN(nC.ProjectedX))
                    {
                        continue;
                    }
                    PointF pt = _convertF(nC);

                    if (pt.X < -20)
                    {
                        continue;
                    }
                    if (pt.X > maxX)
                    {
                        continue;
                    }
                    if (pt.Y > maxY)
                    {
                        continue;
                    }
                    if (pt.Y < -20)
                    {
                        continue;
                    }

                    g.FillRectangle(Brushes.Brown, pt.X, pt.Y, 3, 3);

                    _drawStandoutString(g, nC.Name, Brushes.Beige, (int)pt.X + 3, (int)pt.Y);
                    nCitiesDrawn++;
                }
                g.ResetTransform();
                _drawStandoutString(g, "NCITIES:" + nCitiesDrawn, Brushes.White, 10, 60);
            }

            foreach (var mLine in mapLines)
            {
                bool     stat = ((mLine.Name == "Lat:0") || (mLine.Name == "Lon:0"));
                PointF[] line = _getLine(mLine);
                if (line == null)
                {
                    continue;
                }
                for (int i = 1; i < line.Length; i++)
                {
                    PointF p0 = line[i - 1];
                    if (float.IsNaN(p0.X))
                    {
                        continue;
                    }
                    PointF p1 = line[i];
                    if (float.IsNaN(p1.X))
                    {
                        continue;
                    }
                    g.DrawLine(stat ? _mapThickPen : _mapLinePen, p0, p1);
                }
            }
        }
Esempio n. 2
0
        private void DoubleBuffer_PaintEvent(object sender, PaintEventArgs e)
        {
            toolStripLabelINFO.Text = "Blur:" + settings.BlurAmount + " Opa:" + settings.ShadowOpacity + " Bdr:" + settings.ShadowBorder;
            zoomF = 1.0;

            e.Graphics.SmoothingMode     = SmoothingMode.HighQuality;
            e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
            ttC0.Clear();
            ttC1.Clear();

            Brush br   = new SolidBrush(Color.FromArgb(150, Color.Black));
            Pen   oPen = new Pen(br, 4f);

            RectangleF imageRect = RectangleF.Empty;

            if (settings.BmMain != null)
            {
                var bm  = settings.BmMain;
                var pt0 = _data2screen(0, 0);
                var pt1 = _data2screen(bm.Width, 0);
                var pt2 = _data2screen(bm.Width, bm.Height);
                var pt3 = _data2screen(0, bm.Height);
                imageRect = new RectangleF(pt0.X, pt0.Y, pt1.X - pt0.X, pt2.Y - pt1.Y);
                e.Graphics.DrawImage(bm, imageRect);
                zoomF = ((double)imageRect.Width) / settings.BmMain.Width;
            }

            // make a region
            if (dtL != null && dtR != null && dbL != null && dbR != null)
            {
                // SHADOW
                if (toolStripButtonSHADOW.Checked && !imageRect.IsEmpty)
                {
                    // make a bitmap same area
                    Bitmap shadowBM  = new Bitmap(settings.BmMain.Width, settings.BmMain.Height);
                    var    sGraphics = Graphics.FromImage(shadowBM);
                    sGraphics.SmoothingMode     = SmoothingMode.HighQuality;
                    sGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
                    // clear, transparent
                    sGraphics.Clear(Color.Transparent);
                    Brush sBr = new SolidBrush(Color.FromArgb(settings.ShadowOpacity, Color.Black));


                    // get region of back
                    List <PointF> poly = new List <PointF>();
                    poly.Add(new PointF((float)tL.X, (float)tL.Y));
                    poly.Add(new PointF((float)tR.X, (float)tR.Y));
                    poly.Add(new PointF((float)bR.X, (float)bR.Y));
                    poly.Add(new PointF((float)bL.X, (float)bL.Y));

                    Region reg  = ChartLib.RegionPathHelper.GetRegion(poly);
                    Region uReg = new Region();
                    uReg.MakeEmpty();
                    // translate and union bigger area
                    uReg.Union(reg);
                    reg.Translate((float)settings.ShadowOffset.X, (float)settings.ShadowOffset.Y);                    uReg.Union(reg);
                    reg.Translate(2 * settings.ShadowBorder, 0f); uReg.Union(reg);
                    reg.Translate(0, 2 * settings.ShadowBorder); uReg.Union(reg);
                    reg.Translate(-2 * settings.ShadowBorder, 0f); uReg.Union(reg);
                    // fill the region in translucent black
                    sGraphics.FillRegion(sBr, uReg);

                    // blur it
                    StackBlur.StackBlur.Process(shadowBM, settings.BlurAmount);
                    // draw
                    e.Graphics.DrawImage(shadowBM, imageRect);
                }


                _fill(e.Graphics, Brushes.DimGray, bL, dbL, dtL, tL);
                _fill(e.Graphics, Brushes.DimGray, bL, bR, dbR, dbL);
                _fill(e.Graphics, Brushes.DimGray, tR, dtR, dbR, bR);
                _fill(e.Graphics, Brushes.DimGray, tL, tR, dtR, dtL);

                PointF[] clipRegPt = new PointF[4];
                clipRegPt[0] = _data2screen(dtL);
                clipRegPt[1] = _data2screen(dtR);
                clipRegPt[2] = _data2screen(dbR);
                clipRegPt[3] = _data2screen(dbL);
                Region clipRegion = RegionPathHelper.GetRegion(clipRegPt);
                ttcA.Add(clipRegion, null, settings.PicCorner);
                e.Graphics.FillPolygon(Brushes.LightGray, clipRegPt);

                if (pictureItem != null)
                {
                    e.Graphics.FillPolygon(Brushes.DimGray, clipRegPt);
                    e.Graphics.SetClip(clipRegion, CombineMode.Replace);
                    // draw image.. expand slightly to fix bad edges
                    var        pt0  = _data2screen(imageLocation.X, imageLocation.Y);
                    var        pt1  = _data2screen(imageLocation.X + pictureItem.Width, imageLocation.Y);
                    var        pt2  = _data2screen(imageLocation.X + pictureItem.Width, imageLocation.Y + pictureItem.Height);
                    var        pt3  = _data2screen(imageLocation.X, imageLocation.Y + pictureItem.Height);
                    RectangleF rect = new RectangleF(pt0.X, pt0.Y, pt1.X - pt0.X, pt2.Y - pt1.Y);
                    rect.Inflate(3, 3);
                    e.Graphics.DrawImage(pictureItem, rect);
                    e.Graphics.ResetClip();
                    br   = new SolidBrush(Color.FromArgb(20, Color.Black));
                    oPen = new Pen(br, 2f);
                    e.Graphics.DrawPolygon(oPen, clipRegPt);
                }
            }
            var box0 = settings.Box0;
            var box1 = settings.Box1;

            if (tsbSHOWTRANS.Checked)
            {
                // trans space
                _drawTransBox(e.Graphics, box0);
                _drawTransBox(e.Graphics, box1);

                _drawPoint(e.Graphics, _tr_m0, Brushes.YellowGreen);
                _drawPoint(e.Graphics, _tr_m2, Brushes.YellowGreen);
                //      _drawPoint(e.Graphics, _tr_aux0, Brushes.White);

                // line - measuring point thru m2 to y level of m0, the
                _drawLine(e.Graphics, Pens.Wheat, _tr_sidePoint1, _tr_measuringPoint1);
                _drawLine(e.Graphics, Pens.Wheat, _tr_sidePoint1, _tr_m0);

                _drawLine(e.Graphics, Pens.Gold, box0.TransVanishingPoint, box1.TransVanishingPoint);

                _drawLine(e.Graphics, Pens.LightYellow, box0.TransVanishingPoint, _tr_distancePoint);
                _drawLine(e.Graphics, Pens.LightYellow, box1.TransVanishingPoint, _tr_distancePoint);

                _drawPoint(e.Graphics, _tr_measuringPoint0, Brushes.Goldenrod);
                _drawPoint(e.Graphics, _tr_measuringPoint1, Brushes.Goldenrod);

                _drawPoint(e.Graphics, _tr_tL, Brushes.White);
                _drawPoint(e.Graphics, _tr_bL, Brushes.White);
                _drawPoint(e.Graphics, _tr_bR, Brushes.White);
                _drawPoint(e.Graphics, _tr_tR, Brushes.White);

                _drawLine(e.Graphics, Pens.White, box1.TransVanishingPoint, _tr_tL);

                _drawPoint(e.Graphics, _tr_top, Brushes.LightGoldenrodYellow);
                _drawPoint(e.Graphics, _tr_base, Brushes.LightGoldenrodYellow);

                //_drawLine(e.Graphics, Pens.Cyan, _tr_sideL, _tr_measuringPoint0);
                _drawLine(e.Graphics, Pens.Yellow, _tr_thickBL, _tr_thickBR);
                _drawLine(e.Graphics, Pens.Yellow, _tr_thickTL, _tr_thickBL);
                _drawLine(e.Graphics, Pens.Yellow, _tr_thickTL, _tr_thickTR);
                _drawLine(e.Graphics, Pens.Yellow, _tr_thickBR, _tr_thickTR);
                _drawLine(e.Graphics, Pens.Yellow, _tr_thickBL, _tr_bL);
                _drawLine(e.Graphics, Pens.Yellow, _tr_thickTL, _tr_tL);
                _drawLine(e.Graphics, Pens.Yellow, _tr_thickTR, _tr_tR);
                _drawLine(e.Graphics, Pens.Yellow, _tr_thickBR, _tr_bR);
            }



            if (tsbPERSP.Checked)
            {
                _drawLine(e.Graphics, Pens.OrangeRed, bL, bR);
                _drawLine(e.Graphics, Pens.OrangeRed, bR, tR);
                _drawLine(e.Graphics, Pens.OrangeRed, tR, tL);
                _drawLine(e.Graphics, Pens.OrangeRed, tL, bL);
                _drawLine(e.Graphics, Pens.Orange, dbL, bL);
                _drawLine(e.Graphics, Pens.Orange, dbR, bR);
                _drawLine(e.Graphics, Pens.Orange, dtR, tR);
                _drawLine(e.Graphics, Pens.Orange, dtL, tL);
                _drawPoint(e.Graphics, bL, Brushes.Orange);
                _drawPoint(e.Graphics, bR, Brushes.Orange);
                _drawPoint(e.Graphics, tL, Brushes.Orange);
                _drawPoint(e.Graphics, tR, Brushes.Orange);
            }


            if (tsbPERSP.Checked)
            {
                _drawBox(e.Graphics, box0, ttC0);
                _drawBox(e.Graphics, box1, ttC1);

                _drawLine(e.Graphics, Pens.RoyalBlue, box0.VanishingPoint, box1.VanishingPoint);

                //_drawLine(e.Graphics, Pens.Blue, box0.VanishingPoint, settings.Aux0);
                // _drawLine(e.Graphics, Pens.Blue, box1.VanishingPoint, settings.Aux0);
                //    _drawPoint(e.Graphics, settings.Aux0, Brushes.Green, ttcA);
            }


            if (tsbMEASURE.Checked)
            {
                _drawLine(e.Graphics, Pens.Black, settings.M0, settings.M2);
                _drawPoint(e.Graphics, settings.M0, Brushes.Black, ttcA);
                _drawPoint(e.Graphics, settings.M1, Brushes.Transparent, ttcA);
                _drawPoint(e.Graphics, settings.M2, Brushes.Black);

                if (settings.M0 != null && settings.M2 != null)
                {
                    var pt0 = _data2screen(settings.M0);
                    var pt1 = _data2screen(settings.M2);
                    e.Graphics.DrawString(settings.MeasureDim + "m", this.Font, Brushes.Yellow, (pt0.X + pt1.X) / 2, (pt0.Y + pt1.Y) / 2);
                }
            }

            if (tsbPERSP.Checked)
            {
                _drawLine(e.Graphics, Pens.Orange, dbL, dbR);
                _drawLine(e.Graphics, Pens.Orange, dbR, dtR);
                _drawLine(e.Graphics, Pens.Orange, dtR, dtL);
                _drawLine(e.Graphics, Pens.Orange, dtL, dbL);
            }

            e.Graphics.DrawString(settings.PicWidth + " x " + settings.PicHeight + "m", new Font(this.Font.FontFamily, 20f, FontStyle.Bold, GraphicsUnit.Pixel), Brushes.Black, -1, 0);
            e.Graphics.DrawString(settings.PicWidth + " x " + settings.PicHeight + "m", new Font(this.Font.FontFamily, 20f, FontStyle.Bold, GraphicsUnit.Pixel), Brushes.Black, 1, 0);
            e.Graphics.DrawString(settings.PicWidth + " x " + settings.PicHeight + "m", new Font(this.Font.FontFamily, 20f, FontStyle.Bold, GraphicsUnit.Pixel), Brushes.Black, 0, 1);
            e.Graphics.DrawString(settings.PicWidth + " x " + settings.PicHeight + "m", new Font(this.Font.FontFamily, 20f, FontStyle.Bold, GraphicsUnit.Pixel), Brushes.Black, 0, -1);
            e.Graphics.DrawString(settings.PicWidth + " x " + settings.PicHeight + "m", new Font(this.Font.FontFamily, 20f, FontStyle.Bold, GraphicsUnit.Pixel), Brushes.Yellow, 0, 0);
        }