Пример #1
0
        private void RenderSetupPentagram(SetUpPentagramModel setUpPentagram)
        {
            geometryPainter.PaintPentagram(canvas, new Point(170, 160));
            var points = geometryPainter.GetPentagramValuesPoints(new Point(163, 140));
            var pentagramValueModels = setUpPentagram.GetAllValueModelsOrderBy();

            for (var i = 0; i < 10; i++)
            {
                AddNumberToCanvas(points[i].X, points[i].Y, pentagramValueModels[i]);
            }
        }
Пример #2
0
        private void RenderBlueBackgroundPentagram(SetUpPentagramModel setUpPentagramModel)
        {
            if (eventBaZiModel == null)
            {
                return;
            }

            var redPointIndexesCount = new Dictionary <int, int>();
            var points = geometryPainter.GetPentagramValuesPoints(new Point(163, 280));
            var pentagramValueModels = setUpPentagramModel.GetAllValueModelsOrderBy();
            var redColorIndexes      = pentagramValueModels.Select((x, i) => new { i, x })
                                       .Where(t => t.x.Color.IsRed()).Select(t => t.i).ToList();

            void RenderRedPoint(PeriodsModel period)
            {
                var energyIndex   = MapEnergyToDefaultIndex(period.EventPeriod.Energy);
                var redPointIndex = redColorIndexes.First(x => x == energyIndex * 2 || x == energyIndex * 2 + 1);

                if (!redPointIndexesCount.ContainsKey(redPointIndex))
                {
                    if (redPointIndexesCount.Count >= 3)
                    {
                        return;
                    }

                    AddTextToCanvas(points[redPointIndex].X, points[redPointIndex].Y, "o", Colors.Red);
                    redPointIndexesCount.Add(redPointIndex, 1);
                }
                else
                {
                    AddTextToCanvas(points[redPointIndex].X + redPointIndexesCount[redPointIndex] * 7,
                                    points[redPointIndex].Y, "o", Colors.Red);
                    redPointIndexesCount[redPointIndex]++;
                }
            }

            geometryPainter.PaintPentagram(canvas, new Point(170, 300));
            var cycleModel = cycleModelBuilder.Build(birthDate, eventDatePicker.SelectedDate.Value);

            RenderRedPoint(cycleModel.Day);
            RenderRedPoint(cycleModel.Month);
            RenderRedPoint(cycleModel.Season);
            RenderRedPoint(cycleModel.Year);
            RenderRedPoint(cycleModel.Big);

            var point = RenderBlueBackgroundPentagramHelper.GetPoint(redPointIndexesCount.Keys, points);

            if (point.HasValue)
            {
                AddTextToCanvas(point.Value.X, point.Value.Y, "O", Colors.Blue);
            }
        }
Пример #3
0
        private void Render()
        {
            canvas.Children.Clear();
            setUpPentagramModel = calculator.GetPentagram(birthBaZiModel);

            RenderBaZiBirthModel(birthBaZiModel);
            RenderBaZiEventModel(eventDatePicker.SelectedDate);
            RenderBaZiReceptionModel(receptionDatePicker.SelectedDate);

            RenderSetupPentagram(setUpPentagramModel);
            RenderBlueBackgroundPentagram(setUpPentagramModel);

            RenderAnimalsLine(setUpPentagramModel);
            RenderCycles(new Point(350, 120));
            RenderEnergyCircle(setUpPentagramModel);
        }
Пример #4
0
        private void RenderEnergyCircle(SetUpPentagramModel model)
        {
            if (eventBaZiModel == null)
            {
                return;
            }

            var animalAbbreviations = new[] { "MC", "TR", "VB", "F", "P", "GI", "E", "RP", "C", "IG", "V", "R" };
            var valueModels         = model.GetAllValueModels();

            var start  = new Point(380, 400);
            var points = new List <Point>
            {
                start, new Point(start.X - 100, start.Y),
                new Point(start.X - 100, start.Y + 100), new Point(start.X, start.Y + 100),
                new Point(start.X + 150, start.Y), new Point(start.X + 50, start.Y),
                new Point(start.X + 50, start.Y + 100), new Point(start.X + 150, start.Y + 100),
                new Point(start.X + 300, start.Y), new Point(start.X + 200, start.Y),
                new Point(start.X + 200, start.Y + 100), new Point(start.X + 300, start.Y + 100)
            };

            for (var i = 0; i < points.Count; i++)
            {
                AddTextToCanvas(points[i].X, points[i].Y, animalAbbreviations[i], valueModels[i].Color, 16);
            }

            var arrowsData = geometryPainter.GetEnergyCircleArrowsData(points);

            canvas.Children.Add(new Path
            {
                Data   = Geometry.Parse(arrowsData),
                Stroke = Brushes.Black
            });

            RenderEnergyCircleInnerText(points);

            var animalEnergyAbbrWithColor = new[]
            {
                GetAnimalAbbrWithColor(eventBaZiModel.Year), GetAnimalAbbrWithColor(eventBaZiModel.Month),
                GetAnimalAbbrWithColor(eventBaZiModel.Date)
            };
            var entryPoints = EnergyCircle.EntryPoints.Select(x => (x, new List <string>()))
                              .ToDictionary(x => x.Item1, x => x.Item2);

            RenderColoredArrows(animalEnergyAbbrWithColor, animalAbbreviations, points, entryPoints);
        }
Пример #5
0
        private void RenderAnimalsLine(SetUpPentagramModel model)
        {
            var arrowsData = $"{geometryPainter.GetBigArrowData(new Point(10, 144))}" +
                             $"{geometryPainter.GetBigArrowData(new Point(10, 254))}" +
                             $"{geometryPainter.GetBigArrowData(new Point(10, 364))}" +
                             $"{geometryPainter.GetSmallArrowData(new Point(65, 170))}" +
                             $"{geometryPainter.GetSmallArrowData(new Point(65, 280))}" +
                             $"{geometryPainter.GetSmallArrowData(new Point(65, 390))}";

            canvas.Children.Add(new Path
            {
                Data   = Geometry.Parse(arrowsData),
                Stroke = Brushes.Black
            });

            var yPositions          = new[] { 135, 161, 189, 215, 245, 271, 299, 325, 355, 381, 409, 435 };
            var animalAbbreviations = new[] { "MC", "TR", "VB", "F", "P", "GI", "E", "RP", "C", "IG", "V", "R" };
            var valueModels         = model.GetAllValueModels();
            var starData            = "";

            for (var a = 0; a < 12; a++)
            {
                AddTextToCanvas(30, yPositions[a], animalAbbreviations[a], valueModels[a].Color);
                if (valueModels[a].IsWeak && valueModels[a].Name != null)
                {
                    var index = animalAbbreviations.Select((abbr, i) => new { abbr, i })
                                .Where(x => x.abbr == valueModels[a].Name).Select(x => x.i).First();
                    starData += geometryPainter.GetStarData(new Point(30, yPositions[index]));
                }

                if (valueModels[a].IsWeak && valueModels[a].Name == null)
                {
                    starData += geometryPainter.GetStarData(new Point(30, yPositions[a]));
                }
            }

            canvas.Children.Add(new Path
            {
                Data   = Geometry.Parse(starData),
                Stroke = Brushes.Blue
            });
        }