public Appearance(LogFontSize fontSize, string fontFamily, ColoringMode coloring, PaletteBrightness coloringBrightness) { this.FontSize = fontSize; this.FontFamily = fontFamily; this.Coloring = coloring; this.ColoringBrightness = coloringBrightness; }
static ImmutableArray <IViewItem> CreateViewItems( IEnumerable <IBookmark> bookmarks, IImmutableSet <IBookmark> selected, ImmutableArray <Color> threadColors, ColoringMode coloring ) { var resultBuilder = ImmutableArray.CreateBuilder <IViewItem>(); DateTime?prevTimestamp = null; DateTime?prevSelectedTimestamp = null; bool multiSelection = selected.Count >= 2; int index = 0; foreach (IBookmark bmk in bookmarks) { var ts = bmk.Time.ToUniversalTime(); var ls = bmk.GetLogSource(); var isEnabled = ls != null && ls.Visible; var isSelected = selected.Contains(bmk); var deltaBase = multiSelection ? (isSelected ? prevSelectedTimestamp : null) : prevTimestamp; var delta = deltaBase != null ? ts - deltaBase.Value : new TimeSpan?(); var altDelta = prevTimestamp != null ? ts - prevTimestamp.Value : new TimeSpan?(); int?colorIndex = null; var thread = bmk.Thread; if (coloring == Settings.Appearance.ColoringMode.Threads) { if (!thread.IsDisposed) { colorIndex = thread.ThreadColorIndex; } } if (coloring == Settings.Appearance.ColoringMode.Sources) { if (!thread.IsDisposed && !thread.LogSource.IsDisposed) { colorIndex = thread.LogSource.ColorIndex; } } resultBuilder.Add(new ViewItem() { bookmark = bmk, key = bmk.GetHashCode().ToString(), text = bmk.ToString(), delta = TimeUtils.TimeDeltaToString(delta), altDelta = TimeUtils.TimeDeltaToString(altDelta), isSelected = isSelected, isEnabled = isEnabled, contextColor = threadColors.GetByIndex(colorIndex), index = index }); prevTimestamp = ts; if (isSelected) { prevSelectedTimestamp = ts; } ++index; } return(resultBuilder.ToImmutable()); }
private static Color CharacterizeBlock(byte[] block, ColoringMode coloringMode) { return(Color.FromArgb( coloringMode.Red(block), coloringMode.Green(block), coloringMode.Blue(block) )); }
public static Color Colorize(this Color originalColor, Color targetColor, ColoringMode coloringMode, float lerpAmount = 1.0f) { Color resultColor; switch (coloringMode) { case ColoringMode.Tint: { float s_h, s_s, s_v, t_h, t_s, t_v; Color.RGBToHSV(originalColor, out s_h, out s_s, out s_v); Color.RGBToHSV(targetColor, out t_h, out t_s, out t_v); resultColor = Color.HSVToRGB(t_h, t_s, s_v * t_v); resultColor.a = originalColor.a * targetColor.a; } break; case ColoringMode.Multiply: resultColor = originalColor * targetColor; break; case ColoringMode.Replace: resultColor = targetColor; break; case ColoringMode.ReplaceKeepAlpha: resultColor = targetColor; resultColor.a = originalColor.a; break; case ColoringMode.Add: resultColor = originalColor + targetColor; break; default: throw new ArgumentOutOfRangeException(nameof(coloringMode), coloringMode.ToString("G"), null); } return(Color.Lerp(originalColor, resultColor, lerpAmount)); }
public static Color MMColorize(this Color originalColor, Color targetColor, ColoringMode coloringMode, float lerpAmount = 1.0f) { Color resultColor = Color.white; switch (coloringMode) { case ColoringMode.Tint: { float s_h, s_s, s_v, t_h, t_s, t_v; Color.RGBToHSV(originalColor, out s_h, out s_s, out s_v); Color.RGBToHSV(targetColor, out t_h, out t_s, out t_v); resultColor = Color.HSVToRGB(t_h, t_s, s_v * t_v); resultColor.a = originalColor.a * targetColor.a; } break; case ColoringMode.Multiply: resultColor = originalColor * targetColor; break; case ColoringMode.Replace: resultColor = targetColor; break; case ColoringMode.ReplaceKeepAlpha: resultColor = targetColor; resultColor.a = originalColor.a; break; case ColoringMode.Add: resultColor = originalColor + targetColor; break; default: break; } return(Color.Lerp(originalColor, resultColor, lerpAmount)); }
private void RenderPathCustomColors(PathRule pathRule, ColoringMode coloringMode, MapColorPalette palette, Color fromColor, Color middleColor, Color toColor) { pathRule.UseCustomColors = true; SetRuleColors(pathRule.GetColors(coloringMode, palette, fromColor, middleColor, toColor, GetBucketCount()), pathRule.CustomColors); }
private void RenderShapeCustomColors(ShapeRule shapeRule, ColoringMode coloringMode, MapColorPalette palette, Color fromColor, Color middleColor, Color toColor) { shapeRule.UseCustomColors = true; SetRuleColors(shapeRule.GetColors(coloringMode, palette, fromColor, middleColor, toColor, GetBucketCount()), shapeRule.CustomColors); }
internal Color[] GetColors(ColoringMode coloringMode, MapColorPalette colorPalette, Color startColor, Color middleColor, Color endColor, int colorCount) { if (colorCount == 0) { return(null); } if (coloringMode == ColoringMode.DistinctColors) { return(new ColorGenerator().GenerateColors(colorPalette, colorCount)); } switch (colorCount) { case 1: return(new Color[1] { startColor }); case 2: return(new Color[2] { startColor, endColor }); default: { bool flag = middleColor.A == 0; byte a = startColor.A; _ = middleColor.A; byte a2 = endColor.A; startColor = Color.FromArgb(255, startColor); middleColor = Color.FromArgb(255, middleColor); endColor = Color.FromArgb(255, endColor); Color[] array = new Color[colorCount]; array[0] = startColor; array[colorCount - 1] = endColor; Rectangle rect = new Rectangle(0, 0, colorCount, 1); if (colorCount % 2 == 1) { rect.Width--; } Bitmap bitmap = new Bitmap(colorCount, 1); using (LinearGradientBrush linearGradientBrush = new LinearGradientBrush(rect, startColor, endColor, 0f, isAngleScaleable: false)) { ColorBlend colorBlend = new ColorBlend(); if (flag) { colorBlend.Positions = new float[2] { 0f, 1f }; colorBlend.Colors = new Color[2] { startColor, endColor }; } else { colorBlend.Positions = new float[3] { 0f, 0.5f, 1f }; colorBlend.Colors = new Color[3] { startColor, middleColor, endColor }; } linearGradientBrush.InterpolationColors = colorBlend; using (Graphics graphics = Graphics.FromImage(bitmap)) { graphics.FillRectangle(linearGradientBrush, rect); } } float num = (a2 - a) / (colorCount - 1); float num2 = (int)a; for (int i = 1; i < colorCount - 1; i++) { num2 += num; Color pixel = bitmap.GetPixel(i, 0); array[i] = Color.FromArgb((int)num2, pixel); } return(array); } } }
/// <summary> /// Creates a memsquare from a file. /// </summary> /// <param name="worker">The background worker the function is running on, or null if it isn't</param> /// <param name="fileData">The file to create the memsquare of</param> /// <param name="blockSize">Size of each block in bytes</param> /// <param name="coloringMode">Method in which to color each pixel based on the block</param> /// <returns>A memsquare based on the file</returns> public static Bitmap Generate(BackgroundWorker worker, byte[] fileData, int blockSize, ColoringMode coloringMode) { int fileSize = fileData.Length; // Side length of square must be a power of two for the Hilbert curve, // so therefore to maintain a square the number of blocks must be a square // number. int blockCount = GetBlockCount(fileSize, blockSize); int sideLength = GetSideLength(fileSize, blockSize); Bitmap memsquare = new Bitmap(sideLength, sideLength); for (int i = 0; i < blockCount; ++i) { if (worker != null && worker.CancellationPending) { memsquare.Dispose(); return(null); } byte[] block = GetBlock(fileData, i, blockSize); Color c = CharacterizeBlock(block, coloringMode); Tuple <int, int> position = Utility.HilbertDToXY(sideLength, i); memsquare.SetPixel(position.Item1, position.Item2, c); double percentage = (i + 1) / (double)blockCount * 100.0; // Don't report the percentage too often - otherwise the UI locks up entirely if (worker != null && i % (blockCount / 1000) == 0) { worker.ReportProgress((int)percentage); } } // As we only report every so often, 100% doesn't usually get reported. // Just do it now so everything looks good. if (worker != null) { worker.ReportProgress(100); } return(memsquare); }