Exemple #1
0
            private void GetRandomFlagColors_LoadExisting(IEnumerable<ColorHSV> existing, ColorHSV[] retVal, List<Tuple<ColorHSV, FlagColorCategory>> categorized)
            {
                if (existing == null)
                {
                    return;
                }

                int index = 0;

                foreach (ColorHSV color in existing)
                {
                    if (index >= retVal.Length)
                    {
                        break;
                    }

                    retVal[index] = color;
                    categorized.Add(Tuple.Create(color, Categorize(color)));

                    index++;
                }
            }
Exemple #2
0
            public ColorHSV GetRandomColor(FlagColorCategory category, double? hue = null)
            {
                Random rand = StaticRandom.GetRandomForThread();

                double hueActual = hue ?? rand.NextDouble(360);

                ColorHSV retVal;

                if (category == FlagColorCategory.Other)
                {
                    // This category is under other category rectangles, so do a brute force repeat until match
                    FlagColorCategory cat;
                    do
                    {
                        retVal = new ColorHSV(hueActual, rand.NextDouble(100), rand.NextDouble(100));
                        cat = Categorize(retVal);
                    } while (cat != category);
                }
                else
                {
                    // The color range is stored as a rectangle (X is saturation, Y is value)
                    Rect catRect = this.Categories.First(o => o.Item2 == category).Item1;
                    retVal = new ColorHSV(hueActual, rand.NextDouble(catRect.Left, catRect.Right), rand.NextDouble(catRect.Top, catRect.Bottom));
                }

                return retVal;
            }
Exemple #3
0
            public ColorHSV[] GetRandomFlagColors(int count, IEnumerable<ColorHSV> existing = null)
            {
                if (count > _maxFlagColors)
                {
                    throw new ArgumentOutOfRangeException(string.Format("Can't create that many colors: {0}.  Max allowed: {1}", count.ToString(), _maxFlagColors.ToString()));
                }

                ColorHSV[] retVal = new ColorHSV[count];
                var categorized = new List<Tuple<ColorHSV, FlagColorCategory>>();

                GetRandomFlagColors_LoadExisting(existing, retVal, categorized);

                int index = categorized.Count;
                for (int cntr = 0; cntr < count; cntr++)
                {
                    var color = GetRandomFlagColors_Next(categorized);

                    retVal[cntr] = color.Item1;
                    categorized.Add(color);
                }

                return retVal;
            }
        /// <summary>
        /// Creates or adds to a set of colors to be used by klinth weapons
        /// </summary>
        /// <param name="existing">This is a material definition that may already exist, or partially filled out</param>
        /// <param name="basedOn">This is a way to force the return hue (a spike ball's colors could be based on the handle's colors)</param>
        public static MaterialDefinition[] GetRandomMaterials_Klinth(MaterialDefinition[] existing = null, ColorHSV? basedOn = null)
        {
            List<MaterialDefinition> retVal = new List<MaterialDefinition>();

            Random rand = StaticRandom.GetRandomForThread();

            if (existing != null)
            {
                retVal.AddRange(existing);
            }

            // Main color (in the case of a handle, the only color)
            if (retVal.Count < 1)
            {
                double hue;
                if (basedOn == null)
                {
                    hue = StaticRandom.NextDouble(0, 360);
                }
                else
                {
                    //hue = GetRandomHue(basedOn.Value.H);
                    hue = basedOn.Value.H;      // klinth shouldn't allow an opposite hue (it looks really bad)
                }

                retVal.Add(new MaterialDefinition()
                {
                    DiffuseColor = UtilityWPF.HSVtoRGB(hue, StaticRandom.NextDouble(50, 80), StaticRandom.NextDouble(40, 90)).ToHex(),
                    SpecularColor = UtilityWPF.HSVtoRGB(StaticRandom.NextDouble(0, 360), StaticRandom.NextDouble(50, 80), StaticRandom.NextDouble(40, 90)).ToHex(),
                    EmissiveColor = UtilityWPF.GetRandomColor(0, 255).ToHex()
                });
            }

            // Secondary color (in the case of ball and spikes, this is the spikes)
            if (retVal.Count < 2)
            {
                ColorHSV firstDiff = UtilityWPF.ColorFromHex(retVal[0].DiffuseColor).ToHSV();
                ColorHSV firstSpec = UtilityWPF.ColorFromHex(retVal[0].SpecularColor).ToHSV();
                ColorHSV firstEmis = UtilityWPF.ColorFromHex(retVal[0].EmissiveColor).ToHSV();

                // Needs to be roughly the same color as the ball, just a bit darker
                retVal.Add(new MaterialDefinition()
                {
                    DiffuseColor = UtilityWPF.HSVtoRGB(firstDiff.H, firstDiff.S * 1.25, firstDiff.V * .66d).ToHex(),
                    SpecularColor = UtilityWPF.HSVtoRGB(firstSpec.H, firstSpec.S * 1.1, firstSpec.V).ToHex(),
                    EmissiveColor = UtilityWPF.HSVtoRGB(firstEmis.H, firstEmis.S, firstEmis.V).ToHex(),
                });
            }

            return retVal.ToArray();
        }
Exemple #5
0
            public FlagColorCategory Categorize(ColorHSV color)
            {
                Point colorPoint = new Point(color.S, color.V);

                //NOTE: The rectangle could overlap, but the array is built in order with the intention that the first to match wins
                foreach (var category in this.Categories)
                {
                    if (category.Item1.Contains(colorPoint))
                    {
                        return category.Item2;
                    }
                }

                throw new ApplicationException("Should have found one");
            }
        /// <summary>
        /// Creates or adds to a set of colors to be used by composite weapons
        /// </summary>
        /// <param name="existing">This is a material definition that may already exist, or partially filled out</param>
        /// <param name="basedOn">This is a way to force the return hue (a spike ball's colors could be based on the handle's colors)</param>
        public static MaterialDefinition[] GetRandomMaterials_Composite(MaterialDefinition[] existing = null, ColorHSV? basedOn = null)
        {
            List<MaterialDefinition> retVal = new List<MaterialDefinition>();

            Random rand = StaticRandom.GetRandomForThread();

            if (existing != null)
            {
                retVal.AddRange(existing);
            }

            if (retVal.Count < 1)
            {
                if (basedOn == null)
                {
                    // For the first one, just pick any random color
                    retVal.Add(new MaterialDefinition() { DiffuseColor = UtilityWPF.GetRandomColor(0, 255).ToHex() });
                }
                else
                {
                    // Make this based on the hue of the color passed in
                    retVal.Add(new MaterialDefinition() { DiffuseColor = UtilityWPF.HSVtoRGB(GetRandomHue(basedOn.Value.H), rand.NextDouble(100), rand.NextDouble(100)).ToHex() });
                }
            }

            ColorHSV first = UtilityWPF.ColorFromHex(retVal[0].DiffuseColor).ToHSV();

            if (retVal.Count < 2)
            {
                retVal.Add(new MaterialDefinition() { DiffuseColor = UtilityWPF.HSVtoRGB(GetRandomHue(first.H), rand.NextDouble(100), rand.NextDouble(100)).ToHex() });
            }

            if (retVal.Count < 3)
            {
                retVal.Add(new MaterialDefinition() { DiffuseColor = UtilityWPF.HSVtoRGB(GetRandomHue(first.H), rand.NextDouble(100), rand.NextDouble(100)).ToHex() });
            }

            return retVal.ToArray();
        }
            public NetworkOutputs(string[] names)
            {
                this.Size = names.Length;
                this.Names = names;

                this.DistanceMult = 1.5d / Math.Sqrt(this.Size);        // the 1.5 doesn't mean anything.  It just helps push them apart a little more

                this.Hues = CreateHues(this.Size);

                #region Materials

                SpecularMaterial specular = new SpecularMaterial(new SolidColorBrush(UtilityWPF.ColorFromHex("50FFFFFF")), 2);

                // Colors
                this.DotColors = this.Hues.Select(o =>
                {
                    ColorHSV color = new ColorHSV(o, 75, 75);

                    MaterialGroup material = new MaterialGroup();
                    material.Children.Add(new DiffuseMaterial(new SolidColorBrush(color.ToRGB())));
                    material.Children.Add(specular);

                    return new Tuple<ColorHSV, Material>(color, material);
                }).ToArray();

                // Gray
                this.ColorGray = new ColorHSV(0, 0, 50);

                MaterialGroup material_Gray = new MaterialGroup();
                material_Gray.Children.Add(new DiffuseMaterial(new SolidColorBrush(this.ColorGray.ToRGB())));
                material_Gray.Children.Add(specular);

                this.DotGray = material_Gray;

                #endregion
            }
        private static Item3D[] DrawBrainIOLinks3D(Viewport3D viewport, Tuple<int, int>[] links, Item3D[] items1, Item3D[] items2, Color defaultColor, bool isRainbow)
        {
            const double THICKNESS = .025;

            if (!isRainbow)
            {
                var lines = links.Select(o => Tuple.Create(items1[o.Item1].Position.Value, items2[o.Item2].Position.Value));

                return new[]
                {
                    new Item3D(AddLines(viewport, lines, defaultColor, THICKNESS)),
                };
            }

            List<Item3D> retVal = new List<Item3D>();

            foreach (var byItem1 in links.ToLookup(o => o.Item1))
            {
                //Color color = UtilityWPF.GetRandomColor(150, 220);
                Color color = new ColorHSV(StaticRandom.NextDouble(360), 60, 100).ToRGB();

                var lines = byItem1.Select(o => Tuple.Create(items1[byItem1.Key].Position.Value, items2[o.Item2].Position.Value));

                retVal.Add(new Item3D(AddLines(viewport, lines, color, THICKNESS)));
            }

            return retVal.ToArray();
        }
Exemple #9
0
        private static GeometryModel3D GetEggModel(Point3D position, double radius, BotShellColorsDNA colors)
        {
            // Material
            MaterialGroup material = new MaterialGroup();

            Color baseColor = UtilityWPF.ColorFromHex(colors.InnerColorDiffuse);

            ColorHSV driftedColor = baseColor.ToHSV();
            driftedColor = new ColorHSV(UtilityWPF.GetCappedAngle(driftedColor.H + (colors.DiffuseDrift * StaticRandom.NextDouble(0, 4))), driftedColor.S, driftedColor.V);

            material.Children.Add(new DiffuseMaterial(new SolidColorBrush(driftedColor.ToRGB())));
            material.Children.Add(new SpecularMaterial(new SolidColorBrush(UtilityWPF.ColorFromHex("80FFFFFF")), 20));
            material.Children.Add(new EmissiveMaterial(new SolidColorBrush(UtilityWPF.ColorFromHex("20" + colors.EmissiveColor.Substring(colors.EmissiveColor.Length - 6)))));

            // Geometry Model
            GeometryModel3D retVal = new GeometryModel3D();
            retVal.Material = material;
            retVal.BackMaterial = material;

            retVal.Geometry = UtilityWPF.GetSphere_LatLon(5, radius);

            Transform3DGroup transform = new Transform3DGroup();
            transform.Children.Add(new ScaleTransform3D(new Vector3D(.75d, .75d, 1d)));
            transform.Children.Add(new RotateTransform3D(new QuaternionRotation3D(Math3D.GetRandomRotation())));
            transform.Children.Add(new TranslateTransform3D(position.ToVector()));

            retVal.Transform = transform;

            return retVal;
        }
        private static Visual3D TestSamples_Draw(SketchSample[] sketches, double[] hues)
        {
            const double RADIUS = .5;
            const double DOTRADIUS = .035;

            #region Materials

            SpecularMaterial specular = new SpecularMaterial(new SolidColorBrush(UtilityWPF.ColorFromHex("50FFFFFF")), 2);

            var material_Color = hues.Select(o =>
                {
                    ColorHSV color = new ColorHSV(o, 75, 75);

                    MaterialGroup material = new MaterialGroup();
                    material.Children.Add(new DiffuseMaterial(new SolidColorBrush(color.ToRGB())));
                    material.Children.Add(specular);

                    return new { Color = color, Material = material };
                }).ToArray();

            ColorHSV color_Gray = new ColorHSV(0, 0, 50);
            MaterialGroup material_Gray = new MaterialGroup();
            material_Gray.Children.Add(new DiffuseMaterial(new SolidColorBrush(color_Gray.ToRGB())));
            material_Gray.Children.Add(specular);

            #endregion

            Model3DGroup group = new Model3DGroup();

            foreach (SketchSample sketch in sketches)
            {
                int? matchIndex = UtilityEncog.IsMatch(sketch.NNOutput);

                Material material;
                if (matchIndex == null)
                {
                    sketch.IsMatch = false;
                    sketch.Color = color_Gray;
                    material = material_Gray;
                }
                else
                {
                    sketch.IsMatch = true;
                    sketch.Color = material_Color[matchIndex.Value].Color;
                    material = material_Color[matchIndex.Value].Material;
                }

                sketch.Position = Math3D.GetRandomVector_Spherical(RADIUS).ToPoint();
                sketch.Translate_3DDot = new TranslateTransform3D(sketch.Position.ToVector());

                // Geometry Model
                GeometryModel3D geometry = new GeometryModel3D();
                geometry.Material = material;
                geometry.BackMaterial = material;
                geometry.Geometry = UtilityWPF.GetSphere_Ico(DOTRADIUS, 1, true);

                geometry.Transform = sketch.Translate_3DDot;

                group.Children.Add(geometry);
            }

            ModelVisual3D visual = new ModelVisual3D();
            visual.Content = group;
            return visual;
        }