public static Color GetOpaqueRGBMaxColorForIntents(IIntentStates states) { byte R = 0; byte G = 0; byte B = 0; foreach (IIntentState intentState in states.AsList()) { if (intentState is IIntentState <LightingValue> state) { var lv = state.GetValue(); if (lv.Intensity > 0) { Color intentColor = lv.FullColor; R = Math.Max(R, intentColor.R); G = Math.Max(G, intentColor.G); B = Math.Max(B, intentColor.B); } } else if (intentState is IIntentState <RGBValue> rgbState) { var rv = rgbState.GetValue(); R = Math.Max(R, rv.R); G = Math.Max(G, rv.G); B = Math.Max(B, rv.B); } } return(Color.FromArgb(R, G, B)); }
/// <summary> /// Given one or more intent states, this will calculate a Color that is the combination of them all, in a 'max /// RGB component' fashion (ie. max of R, max of G, max of B). /// </summary> public static Color GetOpaqueRGBMaxColorForIntents(IIntentStates states) { byte R = 0; byte G = 0; byte B = 0; foreach (IIntentState intentState in states) { object value = intentState.GetValue(); if (value is LightingValue) { LightingValue lv = (LightingValue)value; if (lv.Intensity > 0) { Color intentColor = lv.FullColor; R = Math.Max(R, intentColor.R); G = Math.Max(G, intentColor.G); B = Math.Max(B, intentColor.B); } } else if (value is RGBValue) { RGBValue rv = (RGBValue)value; R = Math.Max(R, rv.R); G = Math.Max(G, rv.G); B = Math.Max(B, rv.B); } } return(Color.FromArgb(R, G, B)); }
/// <summary> /// Given one or more intent states, this will calculate a Color that is the combination of them all, in a 'max /// RGB component' fashion (ie. max of R, max of G, max of B). /// </summary> public static Color GetOpaqueRGBMaxColorForIntents(IIntentStates states) { byte R = 0; byte G = 0; byte B = 0; foreach (IIntentState intentState in states) { object value = intentState.GetValue(); if (value is LightingValue) { LightingValue lv = (LightingValue)value; if (lv.Intensity > 0) { Color intentColor = lv.FullColor; R = Math.Max(R, intentColor.R); G = Math.Max(G, intentColor.G); B = Math.Max(B, intentColor.B); } } else if (value is RGBValue) { RGBValue rv = (RGBValue)value; R = Math.Max(R, rv.R); G = Math.Max(G, rv.G); B = Math.Max(B, rv.B); } } return Color.FromArgb(R, G, B); }
public List <Color> GetDiscreteColors(IIntentStates states) { // Get states for each color List <Color> colors = _discreteHandler.GetAlphaAffectedColor(states); return(colors); }
internal Element(Guid id, string name) { Id = id; Name = name; _dataSource = new ElementContextSource(Id); _state = new IntentStateList(); }
private void CreateDiscreteColorPoints(int referenceHeight) { List <Color> colors = _emptyColors; Guid nodeId = Guid.Empty; IIntentStates state = null; foreach (PreviewPixel previewPixel in _pixelCache) { if (previewPixel.NodeId != nodeId) { nodeId = previewPixel.NodeId; state = previewPixel.Node.Element.State; colors = previewPixel.GetDiscreteColors(state); } if (state?.Count > 0) { //All points are the same in standard discrete int col = 1; Vector2 xy; if (_isHighPrecision) { xy = new Vector2((float)previewPixel.Location.X, (float)previewPixel.Location.Y); } else { xy = new Vector2(previewPixel.X, previewPixel.Y); } foreach (Color c in colors) { if (c.A > 0) { _points.Add(xy.X); _points.Add(referenceHeight - xy.Y); _points.Add(previewPixel.Z); _points.Add(c.R); _points.Add(c.G); _points.Add(c.B); _points.Add(c.A); _points.Add(previewPixel.PixelSize); if (col % 2 == 0) { xy.Y += previewPixel.PixelSize; //xy.X = xy.X; } else { xy.X = xy.X + previewPixel.PixelSize; } col++; } } } } }
public Color GetFullColor(IIntentStates states) { var state = states[0]; if (state != null) { return(_fullColorHandler.GetFullColor(state)); } return(Color.Empty); }
public static Color GetAlphaRGBMaxColorForIntents(IIntentStates states) { Color result = GetOpaqueRGBMaxColorForIntents(states); // have calculated the desired hue/saturation from combining the color components above (in a // 'highest-wins in each of R/G/B' fashion). Now we need to figure out the appropriate alpha channel // value for the given color. To do that, convert the RGB color to HSV, get the V value to use as // our intensity, and apply that to the alpha channel. result = Color.FromArgb((byte)(HSV.VFromRgb(result) * Byte.MaxValue), result.R, result.G, result.B); return(result); }
/// <summary> /// Given one or more intent states, this will calculate a Color that is the combination of them all, with an /// alpha channel calculated from the 'brightness' of the color. The combination will occur in the RGB space, /// and will take the maximum component of each color as the resulting color (ie. max of R, max of G, max of B). /// </summary> public static Color GetAlphaRGBMaxColorForIntents(IIntentStates states) { Color result = GetOpaqueRGBMaxColorForIntents(states); // have calculated the desired hue/saturation from combining the color components above (in a // 'highest-wins in each of R/G/B' fashion). Now we need to figure out the appropriate alpha channel // value for the given color. To do that, convert the RGB color to HSV, get the V value to use as // our intensity, and apply that to the alpha channel. HSV hsv = HSV.FromRGB(result); result = Color.FromArgb((byte)(hsv.V * Byte.MaxValue), result.R, result.G, result.B); return result; }
public List <Color> GetAlphaAffectedColor(IIntentStates states) { _colorMap.Clear(); _colors.Clear(); foreach (var intentState in states.AsList()) { intentState.Dispatch(this); } foreach (var d in _colorMap) { var c = d.Key; _colors.Add(Color.FromArgb((byte)(d.Value * 255), c.R, c.G, c.B)); } return(_colors); }
public List<Color> GetAlphaAffectedColor(IIntentStates states) { _colorMap.Clear(); _colors.Clear(); foreach (var intentState in states.AsList()) { intentState.Dispatch(this); } foreach (var d in _colorMap) { var c = d.Key; _colors.Add(Color.FromArgb((byte)(d.Value * 255), c.R, c.G, c.B)); } return _colors; }
public void Draw(FastPixel.FastPixel fp, IIntentStates states, double zoomLevel) { if (_isDiscreteColored) { int col = 1; int zoomedX = (int)(Bounds.X * zoomLevel); Rectangle drawRect = new Rectangle(zoomedX, (int)(Bounds.Y * zoomLevel), Bounds.Width, Bounds.Height); // Get states for each color List <Color> colors = _discreteHandler.GetAlphaAffectedColor(states); foreach (Color c in colors) { if (c != Color.Transparent && c.A > byte.MinValue) { fp.DrawCircle(drawRect, c); if (col % 2 == 0) { drawRect.Y += PixelSize; drawRect.X = zoomedX; } else { drawRect.X = zoomedX + PixelSize; } col++; } } } else { var state = states.FirstOrDefault(); if (state != null) { Color intentColor = _fullColorHandler.GetFullColor(state); if (intentColor.A > 0) { Rectangle drawRect = zoomLevel != 1?new Rectangle((int)(Bounds.X * zoomLevel), (int)(Bounds.Y * zoomLevel), Bounds.Width, Bounds.Height):Bounds; fp.DrawCircle(drawRect, intentColor); } } } }
public void Draw(FastPixel.FastPixel fp, IIntentStates states) { if (_isDiscreteColored) { int col = 1; Rectangle drawRect = new Rectangle(drawArea.X, drawArea.Y, drawArea.Width, drawArea.Height); // Get states for each color List <Color> colors = _discreteHandler.GetAlphaAffectedColor(states); foreach (Color c in colors) { if (c != Color.Transparent && c.A > byte.MinValue) { fp.DrawCircle(drawRect, c); if (col % 2 == 0) { drawRect.Y += PixelSize; drawRect.X = drawArea.X; } else { drawRect.X = drawArea.X + PixelSize; } col++; } } } else { var state = states.FirstOrDefault(); if (state != null) { Color intentColor = _fullColorHandler.GetFullColor(state); if (intentColor.A > 0) { fp.DrawCircle(drawArea, intentColor); } } } }
/// <summary> /// Returns a list of alpha affected distinct colors from the states, combined so that the brightest of each color is returned /// </summary> public static IEnumerable <Color> GetAlphaAffectedDiscreteColorsForIntents(IIntentStates states) { List <Color> colors = new List <Color>(); IEnumerable <IGrouping <Color, IIntentState> > colorStates = states.GroupBy( (x => { if (x is IntentState <LightingValue> ) { return((x as IntentState <LightingValue>).GetValue().HueSaturationOnlyColor); } if (x is IntentState <RGBValue> ) { return((x as IntentState <RGBValue>).GetValue().Color); } return(Color.Empty); } )); foreach (IGrouping <Color, IIntentState> grouping in colorStates) { double intensity = grouping.Max(x => { if (x is IntentState <LightingValue> ) { return((x as IntentState <LightingValue>).GetValue().Intensity); } if (x is IntentState <RGBValue> ) { return((x as IntentState <RGBValue>).GetValue().Intensity); } return(0); }); Color brightest = Color.FromArgb((byte)(intensity * byte.MaxValue), grouping.Key.R, grouping.Key.G, grouping.Key.B); colors.Add(brightest); } return(colors); }
public void Draw(FastPixel.FastPixel fp, IIntentStates states) { if (_isDiscreteColored) { int col = 1; Rectangle drawRect = new Rectangle(drawArea.X, drawArea.Y, drawArea.Width, drawArea.Height); // Get states for each color IEnumerable <Color> colors = IntentHelpers.GetAlphaAffectedDiscreteColorsForIntents(states); foreach (Color c in colors) { if (c != Color.Transparent && c.A > byte.MinValue) { fp.DrawCircle(drawRect, c); if (col % 2 == 0) { drawRect.Y += PixelSize; drawRect.X = drawArea.X; } else { drawRect.X = drawArea.X + PixelSize; } col++; } } } else { Color intentColor = IntentHelpers.GetAlphaRGBMaxColorForIntents(states); if (intentColor != Color.Transparent && intentColor.A > 0) { fp.DrawCircle(drawArea, intentColor); } } }
/// <summary> /// Returns a list of alpha affected distinct colors from the states, combined so that the brightest of each color is returned /// </summary> public static IEnumerable<Color> GetAlphaAffectedDiscreteColorsForIntents(IIntentStates states) { List<Color> colors = new List<Color>(); IEnumerable<IGrouping<Color, IIntentState>> colorStates = states.GroupBy( (x => { if (x is IntentState<LightingValue>) { return (x as IntentState<LightingValue>).GetValue().HueSaturationOnlyColor; } if (x is IntentState<RGBValue>) { return (x as IntentState<RGBValue>).GetValue().Color; } return Color.Empty; } )); foreach (IGrouping<Color, IIntentState> grouping in colorStates) { double intensity = grouping.Max(x => { if (x is IntentState<LightingValue>) { return (x as IntentState<LightingValue>).GetValue().Intensity; } if (x is IntentState<RGBValue>) { return (x as IntentState<RGBValue>).GetValue().Intensity; } return 0; }); Color brightest = Color.FromArgb((byte)(intensity * byte.MaxValue), grouping.Key.R, grouping.Key.G, grouping.Key.B); colors.Add(brightest); } return colors; }
public void Draw(FastPixel.FastPixel fp, IIntentStates states) { if(_isDiscreteColored) { int col = 1; Rectangle drawRect = new Rectangle(drawArea.X, drawArea.Y, drawArea.Width, drawArea.Height); // Get states for each color List<Color> colors = _discreteHandler.GetAlphaAffectedColor(states); foreach (Color c in colors) { if (c != Color.Transparent && c.A > byte.MinValue) { fp.DrawCircle(drawRect, c); if (col % 2 == 0) { drawRect.Y += PixelSize; drawRect.X = drawArea.X; } else { drawRect.X = drawArea.X + PixelSize; } col++; } } } else { var state = states.FirstOrDefault(); if (state != null) { Color intentColor = _fullColorHandler.GetFullColor(state); if (intentColor.A > 0) { fp.DrawCircle(drawArea, intentColor); } } } }
public void ClearStates() { _state = new IntentStateList(); }
public void Update() { _state = _AggregateStateFromContexts(); }
internal Element(Guid id, string name) { Id = id; Name = name; _state = EmptyState; }
public void ClearStates() { _state = EmptyState; }
public void Draw(FastPixel.FastPixel fp, IIntentStates states) { if(_isDiscreteColored) { int col = 1; Rectangle drawRect = new Rectangle(drawArea.X, drawArea.Y, drawArea.Width, drawArea.Height); // Get states for each color IEnumerable<Color> colors = IntentHelpers.GetAlphaAffectedDiscreteColorsForIntents(states); foreach (Color c in colors) { if (c != Color.Transparent && c.A > byte.MinValue) { fp.DrawCircle(drawRect, c); if (col % 2 == 0) { drawRect.Y += PixelSize; drawRect.X = drawArea.X; } else { drawRect.X = drawArea.X + PixelSize; } col++; } } } else { Color intentColor = IntentHelpers.GetAlphaRGBMaxColorForIntents(states); if (intentColor != Color.Transparent && intentColor.A > 0) { fp.DrawCircle(drawArea, intentColor); } } }
public static Dictionary<Color, DiscreteValue> GetAlphaDiscreteColorsForIntents(IIntentStates states) { Dictionary<Color, DiscreteValue> colors = new Dictionary<Color, DiscreteValue>(); IEnumerable<IGrouping<Color, IIntentState>> colorStates = states.GroupBy( (x => { var state = x as IntentState<DiscreteValue>; if (state != null) { return state.GetValue().Color; } return Color.Empty; } )); foreach (IGrouping<Color, IIntentState> grouping in colorStates) { double intensity = grouping.Max(x => { var state = x as IntentState<DiscreteValue>; if (state != null) { return state.GetValue().Intensity; } return 0; }); Color brightest = Color.FromArgb(grouping.Key.R, grouping.Key.G, grouping.Key.B); colors.Add(brightest, new DiscreteValue(brightest, intensity)); } return colors; }
public static Dictionary <Color, DiscreteValue> GetAlphaDiscreteColorsForIntents(IIntentStates states) { Dictionary <Color, DiscreteValue> colors = new Dictionary <Color, DiscreteValue>(); IEnumerable <IGrouping <Color, IIntentState> > colorStates = states.GroupBy( (x => { var state = x as IntentState <DiscreteValue>; if (state != null) { return(state.GetValue().Color); } return(Color.Empty); } )); foreach (IGrouping <Color, IIntentState> grouping in colorStates) { double intensity = grouping.Max(x => { var state = x as IntentState <DiscreteValue>; if (state != null) { return(state.GetValue().Intensity); } return(0); }); Color brightest = Color.FromArgb(grouping.Key.R, grouping.Key.G, grouping.Key.B); colors.Add(brightest, new DiscreteValue(brightest, intensity)); } return(colors); }
private List <IIntentState> GetCombinedState(IIntentStates states) { return(_stateCombinator.Combine(states.AsList())); }