/// <summary>
/// Returns whether or not an enumeration instance a valid value.
/// This method is designed to be used with ValidateValueCallback, and thus
/// matches it's prototype.
/// </summary>
/// <param name="valueObject">
/// Enumeration value to validate.
/// </param>
/// <returns> 'true' if the enumeration contains a valid value, 'false' otherwise. </returns>
public static bool IsEdgeModeValid(object valueObject)
{
EdgeMode value = (EdgeMode)valueObject;
return((value == EdgeMode.Unspecified) ||
(value == EdgeMode.Aliased));
}
/// <summary>
/// Neighbors of the node.
/// </summary>
/// <param name="node">Node which neighbors we want to get.</param>
/// <param name="edgeMode">Out/In/InOut neighbors.</param>
/// <returns>Neighbors of the given node.</returns>
public HashSet <Node> Neighbors(Node node, EdgeMode edgeMode)
{
if (edgeMode == EdgeMode.In)
{
if (!NeighborsIn.ContainsKey(node.Id))
{
return(EmptyNodes);
}
return(NeighborsIn[node.Id]);
}
if (edgeMode == EdgeMode.Out)
{
if (!NeighborsOut.ContainsKey(node.Id))
{
return(EmptyNodes);
}
return(NeighborsOut[node.Id]);
}
if (edgeMode == EdgeMode.InOut)
{
if (!NeighborsAll.ContainsKey(node.Id))
{
return(EmptyNodes);
}
return(NeighborsAll[node.Id]);
}
return(null);
}
/// <summary>
/// Writes the attached property EdgeMode to the given object.
/// </summary>
public static void SetEdgeMode(DependencyObject target, EdgeMode edgeMode)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
target.SetValue(EdgeModeProperty, edgeMode);
}
private void SetAliasingMode()
{
EdgeMode mode = OverlaySettings.EnableAntiAliasing ? EdgeMode.Unspecified : EdgeMode.Aliased;
foreach (Widget widget in Widgets)
{
RenderOptions.SetEdgeMode(widget, mode);
}
}
/// <summary>
/// Normal scale>=1
/// </summary>
/// <param name="isNormal"></param>
private void EditorScaleChangeHandler(bool isNormal)
{
if (isNormal)
{
EdgeMode = EdgeMode.Aliased;
}
else
{
EdgeMode = EdgeMode.Unspecified;
}
}
/// <summary>
/// Returns relevance of the actor on given layer with specific edgemode.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor to get relevance of.</param>
/// <param name="layer">Layer to calculate relevance on.</param>
/// <param name="edgeMode">In/Out/InOut edges.</param>
/// <returns>Relevance of the actor on given layer with specific edgemode.</returns>
public double Relevance(MultilayerNetwork mnet, Actor actor, Layer layer, EdgeMode edgeMode = EdgeMode.InOut)
{
double allLayers = NeighborhoodCentrality(mnet, actor, mnet.Layers, edgeMode);
double selectedLayers = NeighborhoodCentrality(mnet, actor, layer, edgeMode);
if (allLayers == 0)
{
return(0);
}
return(selectedLayers / allLayers);
}
void IMetroDrawingContext.Push(
Matrix transform,
Geometry clip,
double opacity,
Brush opacityMask,
Rect maskBounds,
bool onePrimitive,
// serialization attributes
String nameAttr,
Visual node,
Uri navigateUri,
EdgeMode edgeMode
)
{
m_Flattener.Push(transform, clip, opacity, opacityMask, maskBounds, onePrimitive);
}
public void Push(
Matrix transform,
Geometry clip,
double opacity,
Brush opacityMask,
Rect maskBounds,
bool onePrimitive,
// serialization attributes
String nameAttr,
Visual node,
Uri navigateUri,
EdgeMode edgeMode
)
{
opacity = Utility.NormalizeOpacity(opacity);
int pushCount = 0;
if (!transform.IsIdentity)
{
_context.PushTransform(new MatrixTransform(transform));
pushCount++;
}
if (clip != null)
{
_context.PushClip(clip);
pushCount++;
}
if (!Utility.IsOpaque(opacity))
{
_context.PushOpacity(opacity);
pushCount++;
}
if (opacityMask != null)
{
_context.PushOpacityMask(opacityMask);
pushCount++;
}
_push.Push(pushCount);
}
/// <summary>
/// Returns degree on provided layer.
/// </summary>
/// <param name="mnet">Multlayer network model.</param>
/// <param name="actor">Actor.</param>
/// <param name="layer">Single Layer.</param>
/// <param name="edgeMode">In / Out / All, mode of edge.</param>
/// <returns>Degree of the Actor.</returns>
public int Degree(MultilayerNetwork mnet, Actor actor, Layer layer, EdgeMode edgeMode)
{
var degree = 0;
// All nodes with this ACTOR.
foreach (var node in mnet.GetNodes(actor))
{
// All neighbors of this NODE, with the correct edgeMode (In / Out / Or both).
foreach (var neighbor in mnet.Neighbors(node, edgeMode))
{
// We go through all his neighbors, and if the neighbor is on the provided layer
// we increase his degree by 1.
if (neighbor.Layer == layer)
{
degree += 1;
}
}
}
return(degree);
}
public tk2dTileMapEditorBrush(tk2dTileMapEditorBrush source)
{
this.name = source.name;
this.type = source.type;
this.paintMode = source.paintMode;
tiles = new tk2dSparseTile[source.tiles.Length];
for (int i = 0; i < source.tiles.Length; ++i)
{
tiles[i] = new tk2dSparseTile(source.tiles[i]);
}
multiSelectTiles = new int[source.multiSelectTiles.Length];
for (int i = 0; i < source.multiSelectTiles.Length; ++i)
{
multiSelectTiles[i] = source.multiSelectTiles[i];
}
edgeMode = source.edgeMode;
multiLayer = source.multiLayer;
overrideWithSpriteBounds = source.overrideWithSpriteBounds;
}
static extern void gimp_pixel_fetcher_set_edge_mode(IntPtr pf, EdgeMode mode);
private void ClearEdgeMode()
{
_edgeMode = RenderOptions.GetEdgeMode(this);
RenderOptions.SetEdgeMode(this, EdgeMode.Aliased);
}
private void ResetEdgeMode()
{
this.EdgeMode = EdgeMode.None;
}
private void ResetEdgeMode()
{
EdgeMode = EdgeMode.None;
}
/// <summary>
/// Returns exclusive relevance of the actor on given layer with specific edgemode.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor to get exclusive relevance of.</param>
/// <param name="layer">Layer to calculate exclusive relevance on.</param>
/// <param name="edgeMode">In/Out/InOut edges.</param>
/// <returns>Exclusive relevance of the actor on given layer with specific edgemode.</returns>
public double ExclusiveRelevance(MultilayerNetwork mnet, Actor actor, Layer layer, EdgeMode edgeMode = EdgeMode.InOut)
{
Layer flattened = mnet.GetLayer("flattened");
var test = new HashSet <Layer>(mnet.GetLayers().Except(new HashSet <Layer>()
{
flattened
}));
double allLayers = NeighborhoodCentrality(mnet, actor, new HashSet <Layer>(mnet.GetLayers().Except(new HashSet <Layer>()
{
flattened
})), edgeMode);
double selectedLayers = ExclusiveNeighborhood(mnet, actor, layer, edgeMode);
if (allLayers == 0)
{
return(0);
}
return(selectedLayers / allLayers);
}
/// <summary>
/// Returns means of degrees on the provided layers.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor.</param>
/// <param name="layers">HashSet of layers.</param>
/// <param name="edgeMode">In / Out / All, mode of edge.</param>
/// <returns>Mean of degrees.</returns>
public double DegreeMean(MultilayerNetwork mnet, Actor actor, HashSet <Layer> layers, EdgeMode edgeMode)
{
var degrees = new List <double>();
foreach (var layer in layers)
{
degrees.Add(Degree(mnet, actor, layer, edgeMode));
}
return(degrees.Average());
}
/// <summary>
/// Convolve with a kernel consisting of one column.
/// </summary>
/// <param name="kernel"></param>
/// <param name="inPixels"></param>
/// <param name="outPixels"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="alpha"></param>
/// <param name="edgeAction"></param>
public static void ConvolveV(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, bool alpha, EdgeMode edgeAction) {
int index = 0;
float[] matrix = kernel.GetKernel();
int rows = kernel.Height;
int rows2 = rows/2;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
float r = 0, g = 0, b = 0, a = 0;
for (int row = -rows2; row <= rows2; row++) {
int iy = y + row;
int ioffset;
if (iy < 0) {
if (edgeAction == EdgeMode.Clamp)
ioffset = 0;
else if (edgeAction == EdgeMode.Wrap)
ioffset = ((y + height)%height)*width;
else
ioffset = iy*width;
}
else if (iy >= height) {
if (edgeAction == EdgeMode.Clamp)
ioffset = (height - 1)*width;
else if (edgeAction == EdgeMode.Wrap)
ioffset = ((y + height)%height)*width;
else
ioffset = iy*width;
}
else
ioffset = iy*width;
float f = matrix[row + rows2];
if (f != 0) {
int rgb = inPixels[ioffset + x];
a += f*((rgb >> 24) & 0xff);
r += f*((rgb >> 16) & 0xff);
g += f*((rgb >> 8) & 0xff);
b += f*(rgb & 0xff);
}
}
int ia = alpha ? PixelUtils.Clamp((int)(a + 0.5)) : 0xff;
int ir = PixelUtils.Clamp((int)(r + 0.5));
int ig = PixelUtils.Clamp((int)(g + 0.5));
int ib = PixelUtils.Clamp((int)(b + 0.5));
outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
}
}
}
/// <summary>
/// Returns exclusive neighborhood of given actor on given layer with specific edgemode.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor to get exclusive neighborhood of.</param>
/// <param name="layer">Layer to calculate exclusive neighborhood on.</param>
/// <param name="edgeMode">In/Out/InOut edges.</param>
/// <returns>Exclusive neighborhood of given actor on given layer with specific edgemode.</returns>
public int ExclusiveNeighborhood(MultilayerNetwork mnet, Actor actor, Layer layer, EdgeMode edgeMode = EdgeMode.InOut)
{
Layer flattened = mnet.GetLayer("flattened");
// All layers except the layers in parameter.
var layers = new HashSet <Layer> {
layer
};
var layerSupplement = new HashSet <Layer>(mnet.GetLayers().Except(new HashSet <Layer>()
{
flattened
}).Except(layers));
var a = Neighbors(mnet, actor, layers, edgeMode);
var b = Neighbors(mnet, actor, layerSupplement, edgeMode);
var aMinusB = new HashSet <Actor>(a.Except(b));
return(aMinusB.Count);
}
/// <summary>
/// Convolve with a 2D kernel.
/// </summary>
/// <param name="kernel"></param>
/// <param name="inPixels"></param>
/// <param name="outPixels"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="alpha"></param>
/// <param name="edgeAction"></param>
public static void ConvolveHV(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, bool alpha, EdgeMode edgeAction) {
int index = 0;
float[] matrix = kernel.GetKernel();
int rows = kernel.Height;
int cols = kernel.Width;
int rows2 = rows/2;
int cols2 = cols/2;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
float r = 0, g = 0, b = 0, a = 0;
for (int row = -rows2; row <= rows2; row++) {
int iy = y + row;
int ioffset;
if (0 <= iy && iy < height)
ioffset = iy*width;
else if (edgeAction == EdgeMode.Clamp)
ioffset = y*width;
else if (edgeAction == EdgeMode.Wrap)
ioffset = ((iy + height)%height)*width;
else
continue;
int moffset = cols*(row + rows2) + cols2;
for (int col = -cols2; col <= cols2; col++) {
float f = matrix[moffset + col];
if (f != 0) {
int ix = x + col;
if (!(0 <= ix && ix < width)) {
if (edgeAction == EdgeMode.Clamp)
ix = x;
else if (edgeAction == EdgeMode.Wrap)
ix = (x + width)%width;
else
continue;
}
int rgb = inPixels[ioffset + ix];
a += f*((rgb >> 24) & 0xff);
r += f*((rgb >> 16) & 0xff);
g += f*((rgb >> 8) & 0xff);
b += f*(rgb & 0xff);
}
}
}
int ia = alpha ? PixelUtils.Clamp((int)(a + 0.5)) : 0xff;
int ir = PixelUtils.Clamp((int)(r + 0.5));
int ig = PixelUtils.Clamp((int)(g + 0.5));
int ib = PixelUtils.Clamp((int)(b + 0.5));
outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
}
}
}
/// <summary>
/// Convolve with a kernel consisting of one row.
/// </summary>
/// <param name="kernel"></param>
/// <param name="inPixels"></param>
/// <param name="outPixels"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="alpha"></param>
/// <param name="edgeAction"></param>
public static void ConvolveH(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, bool alpha, EdgeMode edgeAction) {
int index = 0;
float[] matrix = kernel.GetKernel();
int cols = kernel.Width;
int cols2 = cols/2;
for (int y = 0; y < height; y++) {
int ioffset = y*width;
for (int x = 0; x < width; x++) {
float r = 0, g = 0, b = 0, a = 0;
int moffset = cols2;
for (int col = -cols2; col <= cols2; col++) {
float f = matrix[moffset + col];
if (f != 0) {
int ix = x + col;
if (ix < 0) {
if (edgeAction == EdgeMode.Clamp)
ix = 0;
else if (edgeAction == EdgeMode.Wrap)
ix = (x + width)%width;
}
else if (ix >= width) {
if (edgeAction == EdgeMode.Clamp)
ix = width - 1;
else if (edgeAction == EdgeMode.Wrap)
ix = (x + width)%width;
}
int rgb = inPixels[ioffset + ix];
a += f*((rgb >> 24) & 0xff);
r += f*((rgb >> 16) & 0xff);
g += f*((rgb >> 8) & 0xff);
b += f*(rgb & 0xff);
}
}
int ia = alpha ? PixelUtils.Clamp((int)(a + 0.5)) : 0xff;
int ir = PixelUtils.Clamp((int)(r + 0.5));
int ig = PixelUtils.Clamp((int)(g + 0.5));
int ib = PixelUtils.Clamp((int)(b + 0.5));
outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
}
}
}
/// <summary>
/// Convolve a block of pixels
/// </summary>
/// <param name="kernel"></param>
/// <param name="inPixels"></param>
/// <param name="outPixels"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="alpha"></param>
/// <param name="edgeAction"></param>
public static void Convolve(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, bool alpha, EdgeMode edgeAction) {
if (kernel.Height == 1)
ConvolveH(kernel, inPixels, outPixels, width, height, alpha, edgeAction);
else if (kernel.Width == 1)
ConvolveV(kernel, inPixels, outPixels, width, height, alpha, edgeAction);
else
ConvolveHV(kernel, inPixels, outPixels, width, height, alpha, edgeAction);
}
/// <summary>
/// Convolve a block of pixels.
/// </summary>
/// <param name="kernel"></param>
/// <param name="inPixels"></param>
/// <param name="outPixels"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="edgeAction"></param>
public static void Convolve(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, EdgeMode edgeAction) {
Convolve(kernel, inPixels, outPixels, width, height, true, edgeAction);
}
public static IReadOnlyCollection <DateTimeWindow> GetWindowsBetween(DateTime start, DateTime end, IReadOnlyCollection <DateTimeRange> granularities, EdgeMode edges = EdgeMode.Shrink)
{
var result = new List <DateTimeWindow>();
if (start >= end || granularities.Count == 0)
{
return(result);
}
var ranges = granularities.OrderByDescending(g => g).ToArray();
AppendWindowsBetween(start, end, ranges, 0, result);
// In 'Grow' mode, ensure the returned list of buckets **at least** covers the start and end times
if (edges == EdgeMode.Grow)
{
var smallestRange = ranges.Last();
if (result.Count == 0 || result[0].start > start)
{
// No buckets fit, or start bucket starts too late.
// Add the smallest bucket starting before the start time
var startWindow = DateTimeWindow.Find(start, smallestRange);
result.Insert(0, startWindow);
}
var lastWindow = result.Last();
if (lastWindow.end < end)
{
// End bucket finishes too early.
// Add the smallest bucket starting before the end time
var finalWindow = DateTimeWindow.Find(end, smallestRange);
result.Add(finalWindow);
}
}
return(result.AsReadOnly());
}
/// <summary>
/// Returns neighborhood centrality of given actor on given layer with specific edgemode.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor to get neighborhood of.</param>
/// <param name="layer">Layer to get neighborhood on.</param>
/// <param name="edgeMode">In/Out/InOut edges.</param>
/// <returns>Neighborhood centrality of given actor on given layer with specific edgemode.</returns>
public int NeighborhoodCentrality(MultilayerNetwork mnet, Actor actor, Layer layer, EdgeMode edgeMode = EdgeMode.InOut)
{
return(Neighbors(mnet, actor, layer, edgeMode).Count);
}
/// <summary>
/// Writes the attached property EdgeMode to the given object.
/// </summary>
public static void SetEdgeMode(DependencyObject target, EdgeMode edgeMode)
{
if (target == null) { throw new ArgumentNullException("target"); }
target.SetValue(EdgeModeProperty, edgeMode);
}
/// <summary>
/// Returns connective redundancy of given actor on given set of layers with specific edgemode.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor to get connective redundancy of.</param>
/// <param name="layers">Layers to get connective redundancy on.</param>
/// <param name="edgeMode">In/Out/InOut edges.</param>
/// <returns>Connective redundancy of given actor on given set of layers with specific edgemode.</returns>
public double ConnectiveRedundancy(MultilayerNetwork mnet, Actor actor, HashSet <Layer> layers, EdgeMode edgeMode = EdgeMode.InOut)
{
return(1 - Math.Max((NeighborhoodCentrality(mnet, actor, layers, edgeMode) / Degree(mnet, actor, layers, edgeMode)), 0));
}
/// <summary>
/// Blur and transpose a block of ARGB pixels.
/// </summary>
/// <param name="kernel"></param>
/// <param name="inPixels"></param>
/// <param name="outPixels"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="alpha"></param>
/// <param name="premultiply"></param>
/// <param name="unpremultiply"></param>
/// <param name="edgeAction"></param>
public static void ConvolveAndTranspose(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, bool alpha, bool premultiply, bool unpremultiply, EdgeMode edgeAction) {
float[] matrix = kernel.GetKernel();
int cols = kernel.Width;
int cols2 = cols/2;
for (int y = 0; y < height; y++) {
int index = y;
int ioffset = y*width;
for (int x = 0; x < width; x++) {
float r = 0, g = 0, b = 0, a = 0;
int moffset = cols2;
for (int col = -cols2; col <= cols2; col++) {
float f = matrix[moffset + col];
if (f != 0) {
int ix = x + col;
if (ix < 0) {
if (edgeAction == EdgeMode.Clamp)
ix = 0;
else if (edgeAction == EdgeMode.Wrap)
ix = (x + width)%width;
}
else if (ix >= width) {
if (edgeAction == EdgeMode.Clamp)
ix = width - 1;
else if (edgeAction == EdgeMode.Wrap)
ix = (x + width)%width;
}
int rgb = inPixels[ioffset + ix];
int pa = (rgb >> 24) & 0xff;
int pr = (rgb >> 16) & 0xff;
int pg = (rgb >> 8) & 0xff;
int pb = rgb & 0xff;
if (premultiply) {
float a255 = pa*(1.0f/255.0f);
pr = (int)(pr*a255);
pg = (int)(pg*a255);
pb = (int)(pb*a255);
}
a += f*pa;
r += f*pr;
g += f*pg;
b += f*pb;
}
}
if (unpremultiply && a != 0 && a != 255) {
float f = 255.0f/a;
r *= f;
g *= f;
b *= f;
}
int ia = alpha ? PixelUtils.Clamp((int)(a + 0.5)) : 0xff;
int ir = PixelUtils.Clamp((int)(r + 0.5));
int ig = PixelUtils.Clamp((int)(g + 0.5));
int ib = PixelUtils.Clamp((int)(b + 0.5));
outPixels[index] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
index += height;
}
}
}
public void Push(
Transform transform,
Geometry clip,
double opacity,
Brush opacityMask,
Rect maskBounds,
bool onePrimitive,
String nameAttr,
Visual node,
Uri navigateUri,
EdgeMode edgeMode)
{
Debug.Assert(Utility.IsValid(opacity), "Invalid opacity should clip subtree");
Matrix mat = Matrix.Identity;
if (transform != null)
{
mat = transform.Value;
}
// opacity mask might be VisualBrush, hence ReduceBrush to reduce to DrawingBrush
Debug.Assert(!BrushProxy.IsEmpty(opacityMask), "empty opacity mask should not result in Push");
_dc.Push(
mat,
clip,
opacity,
ReduceBrush(opacityMask, maskBounds),
maskBounds,
onePrimitive,
nameAttr,
node,
navigateUri,
edgeMode
);
// prepend to transforms and clipping stack
mat.Append(Transform);
_fullTransform.Add(mat);
// transform clip to world space, intersect with current clip, and push
if (clip == null)
{
// push current clipping
clip = Clip;
}
else
{
clip = Utility.TransformGeometry(clip, Transform);
bool empty;
clip = Utility.Intersect(clip, Clip, Matrix.Identity, out empty);
if (empty)
{
clip = Geometry.Empty;
}
}
_fullClip.Add(clip);
}
private void ClearEdgeMode()
{
_edgeMode = RenderOptions.GetEdgeMode(this);
RenderOptions.SetEdgeMode(this, EdgeMode.Aliased);
}
/// <summary>
/// Rasterizes Visual and its descendents with optional bitmap effect. Also handles Visual opacity.
/// </summary>
/// <param name="visual"></param>
/// <param name="nameAttr">Preserve Visual name attribute</param>
/// <param name="navigateUri">Preserve FixedPage.NavigateUri</param>
/// <param name="edgeMode">Preserve RenderOptions.EdgeMode</param>
/// <param name="visualTransform">Visual.Transform</param>
/// <param name="visualToWorldTransform">Full transform from Visual to world space, including visual transform prepended</param>
/// <param name="inheritedTransformHint">
/// Transformation above VisualTreeFlattener instance. This is needed if we're reducing VisualBrush to
/// DrawingBrush to increase rasterization fidelity if brush is small, but will eventually fill large region.
/// </param>
/// <param name="clip">Clip in world space</param>
/// <param name="effect">Optional bitmap effect</param>
public void DrawRasterizedVisual(
Visual visual,
string nameAttr,
Uri navigateUri,
EdgeMode edgeMode,
Transform visualTransform,
Matrix visualToWorldTransform,
Matrix inheritedTransformHint,
Geometry clip,
Effect effect
)
{
Debug.Assert(visual != null);
// Compute the bounding box of the visual and its descendants
Rect bounds = VisualTreeHelper.GetContentBounds(visual);
bounds.Union(VisualTreeHelper.GetDescendantBounds(visual));
if (!Utility.IsRenderVisible(bounds))
{
return;
}
// transform clip to visual space
if (clip != null)
{
Matrix worldToVisualTransform = visualToWorldTransform;
worldToVisualTransform.Invert();
clip = Utility.TransformGeometry(clip, worldToVisualTransform);
}
//
// Clip visual bounds to rasterization clipping geometry.
// We can't clip to Visual clipping geometry, since bitmap effects are applied
// without clipping. For example, the blur effect looks different if you clip first
// then apply effect, compared to applying the effect and then clipping.
//
bounds = PerformRasterizationClip(bounds, visualToWorldTransform);
if (!Utility.IsRenderVisible(bounds))
{
return;
}
//
// Rasterize Visual to IMetroDrawingContext with optional banding, depending
// on whether bitmap effect is present. We can Push/Pop/Draw directly on _dc
// since the input we provide it is already normalized (no DrawingImage, for example).
// We also don't need Transform or Clip to be updated.
//
_dc.Push(
visualTransform == null ? Matrix.Identity : visualTransform.Value,
clip,
1.0,
null,
Rect.Empty,
/*onePrimitive=*/ false, // we Push and DrawImage below, which counts as 2 primitives
nameAttr,
visual,
navigateUri,
edgeMode
);
Matrix bitmapToVisualTransform;
BitmapSource bitmap;
// If we have an Effect, we may need to inflate the bounds to account for the effect's output.
if (effect != null)
{
bounds = effect.GetRenderBounds(bounds);
}
//
// Rasterize visual in its entirety. Banding is not useful at this point since
// the resulting bands are all kept in memory anyway. Plus transformation is applied
// to the band, which causes gaps between bands if they're rotated (bug 1562237).
//
// Banding is performed at GDIExporter layer just prior to sending images to the printer.
//
bitmap = Utility.RasterizeVisual(
visual,
bounds,
visualToWorldTransform * inheritedTransformHint,
out bitmapToVisualTransform
);
if (bitmap != null)
{
_dc.Push(bitmapToVisualTransform, null, 1.0, null, Rect.Empty, /*onePrimitive=*/ true, null, null, null, EdgeMode.Unspecified);
_dc.DrawImage(bitmap, new Rect(0, 0, bitmap.Width, bitmap.Height));
_dc.Pop();
}
_dc.Pop();
}
/**
* Kontruktor pro tridu AutomatEdge.
*
* atribut endState urcuje do ktereho stavu prechod vede
* atribut mode urcuje, zda pokud po hrane prejdeme, tak dochazi k zanorovani, ci vynorovani
**/
public AutomatEdge(AutomatState endState, EdgeMode mode)
{
this.endState = endState;
this.edgeMode = mode;
}
public static void ConvolveAndTranspose(Kernel kernel, BitmapData inPixels, BitmapData outPixels, int width, int height, bool alpha, bool premultiply, bool unpremultiply, EdgeMode edgeAction)
{
unsafe {
var matrix = kernel.GetKernel();
var halfKernalWidth = kernel.Width / 2;
var bytesPerPixel = Image.GetPixelFormatSize(inPixels.PixelFormat) / 8;
var hasAlpha = PixelFormat.Alpha.HasFlag(inPixels.PixelFormat);
var sourceStart = (byte *)inPixels.Scan0;
var destinationStart = (byte *)outPixels.Scan0;
Parallel.For(0, height, y => {
var index = y;
var baseOffset = y * width;
for (var x = 0; x < width; x++)
{
var r = 0f;
var g = 0f;
var b = 0f;
var a = 0f;
for (var col = -halfKernalWidth; col <= halfKernalWidth; col++)
{
var f = matrix[halfKernalWidth + col];
if (f == 0)
{
continue;
}
var offsetX = x + col;
if (offsetX < 0)
{
switch (edgeAction)
{
case EdgeMode.Clamp:
offsetX = 0;
break;
case EdgeMode.Wrap:
offsetX = (x + width) % width;
break;
}
}
else if (offsetX >= width)
{
switch (edgeAction)
{
case EdgeMode.Clamp:
offsetX = width - 1;
break;
case EdgeMode.Wrap:
offsetX = (x + width) % width;
break;
}
}
var sourceOffset = sourceStart + ((baseOffset + offsetX) * bytesPerPixel);
var sourceR = sourceOffset[0];
var sourceG = sourceOffset[1];
var sourceB = sourceOffset[2];
byte sourceA = 0;
if (hasAlpha)
{
sourceA = sourceOffset[3];
}
if (premultiply && hasAlpha)
{
var alphaMultiply = sourceA * (1.0f / 255.0f);
sourceR = (byte)(sourceR * alphaMultiply);
sourceG = (byte)(sourceG * alphaMultiply);
sourceB = (byte)(sourceB * alphaMultiply);
}
if (hasAlpha)
{
a += f * sourceA;
}
r += f * sourceR;
g += f * sourceG;
b += f * sourceB;
}
if (unpremultiply && hasAlpha && a != 0 && a != 255)
{
var f = 255.0f / a;
r *= f;
g *= f;
b *= f;
}
var destinationA = alpha ? ClampByte((int)(a + 0.5)) : (byte)0xff;
var destinationR = ClampByte(r + 0.5);
var destinationG = ClampByte(g + 0.5);
var destinationB = ClampByte(b + 0.5);
var destOffset = destinationStart + (index * bytesPerPixel);
destOffset[0] = destinationR;
destOffset[1] = destinationG;
destOffset[2] = destinationB;
if (hasAlpha)
{
destOffset[3] = destinationA;
}
index += height;
}
});
}
}
public static void SetSmallEdgeMode(DependencyObject obj, EdgeMode value)
{
obj.SetValue(SmallEdgeModeProperty, value);
}
internal static extern IP_RET SelectiveBlur(ref TMatrix Src, ref TMatrix Dest, int Radius, int Threshold, EdgeMode Edge);
// Old implementation.
private int NeighborhoodCentrality_(MultilayerNetwork mnet, Actor actor, HashSet <Layer> layers, EdgeMode edgeMode = EdgeMode.InOut)
{
// Empty hashset to add checked actors.
var actors = new HashSet <Actor>();
var neighborhood = 0;
// All nodes with this ACTOR.
foreach (var node in mnet.GetNodes(actor))
{
// All neighbors of this NODE, with the correct edgeMode (In / Out / Or both).
foreach (var neighbor in mnet.Neighbors(node, edgeMode))
{
// If there is a layer with this neighbor it means, that this NODE has this neighbor
// on this layer, so we increase his degree by 1 IF actor on this node is still available.
if (layers.Contains(neighbor.Layer) && actors.Add(neighbor.Actor))
{
neighborhood += 1;
}
}
}
return(neighborhood);
}
/// <summary>
/// Convolve with a kernel consisting of one column.
/// </summary>
/// <param name="kernel"></param>
/// <param name="inPixels"></param>
/// <param name="outPixels"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="alpha"></param>
/// <param name="edgeAction"></param>
public static void ConvolveV(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, bool alpha, EdgeMode edgeAction)
{
int index = 0;
float[] matrix = kernel.GetKernel();
int rows = kernel.Height;
int rows2 = rows / 2;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
float r = 0, g = 0, b = 0, a = 0;
for (int row = -rows2; row <= rows2; row++)
{
int iy = y + row;
int ioffset;
if (iy < 0)
{
if (edgeAction == EdgeMode.Clamp)
{
ioffset = 0;
}
else if (edgeAction == EdgeMode.Wrap)
{
ioffset = ((y + height) % height) * width;
}
else
{
ioffset = iy * width;
}
}
else if (iy >= height)
{
if (edgeAction == EdgeMode.Clamp)
{
ioffset = (height - 1) * width;
}
else if (edgeAction == EdgeMode.Wrap)
{
ioffset = ((y + height) % height) * width;
}
else
{
ioffset = iy * width;
}
}
else
{
ioffset = iy * width;
}
float f = matrix[row + rows2];
if (f != 0)
{
int rgb = inPixels[ioffset + x];
a += f * ((rgb >> 24) & 0xff);
r += f * ((rgb >> 16) & 0xff);
g += f * ((rgb >> 8) & 0xff);
b += f * (rgb & 0xff);
}
}
int ia = alpha ? PixelUtils.Clamp((int)(a + 0.5)) : 0xff;
int ir = PixelUtils.Clamp((int)(r + 0.5));
int ig = PixelUtils.Clamp((int)(g + 0.5));
int ib = PixelUtils.Clamp((int)(b + 0.5));
outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
}
}
}
private MathUtils mathUtils = MathUtils.Instance; //new MathUtils();
#region Degree
/// <summary>
/// Returns degree of the actor on provided layers.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor.</param>
/// <param name="layers">HashSet of layers.</param>
/// <param name="edgeMode">In / Out / All, mode of edge.</param>
/// <returns>Degree of the Actor.</returns>
public int Degree(MultilayerNetwork mnet, Actor actor, HashSet <Layer> layers, EdgeMode edgeMode)
{
var degree = 0;
// All nodes with this ACTOR.
foreach (var node in mnet.GetNodes(actor))
{
// All neighbors of this NODE, with the correct edgeMode (In / Out / Or both).
foreach (var neighbor in mnet.Neighbors(node, edgeMode))
{
// If there is a layer with this neighbor it means, that this NODE has this neighbor
// on this layer, so we increase his degree by 1.
if (layers.Contains(neighbor.Layer))
{
degree += 1;
}
}
}
return(degree);
}
static extern void gimp_pixel_fetcher_set_edge_mode(IntPtr pf,
EdgeMode mode);
public tk2dTileMapEditorBrush(tk2dTileMapEditorBrush source)
{
this.name = source.name;
this.type = source.type;
this.paintMode = source.paintMode;
tiles = new tk2dSparseTile[source.tiles.Length];
for (int i = 0; i < source.tiles.Length; ++i)
tiles[i] = new tk2dSparseTile(source.tiles[i]);
multiSelectTiles = new int[source.multiSelectTiles.Length];
for (int i = 0; i < source.multiSelectTiles.Length; ++i)
multiSelectTiles[i] = source.multiSelectTiles[i];
edgeMode = source.edgeMode;
multiLayer = source.multiLayer;
overrideWithSpriteBounds = source.overrideWithSpriteBounds;
}
public static void SetEdgeMode(System.Windows.DependencyObject target, EdgeMode edgeMode)
{
}
/// <summary>
/// Blur and transpose a block of ARGB pixels.
/// </summary>
/// <param name="kernel"></param>
/// <param name="inPixels"></param>
/// <param name="outPixels"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="alpha"></param>
/// <param name="premultiply"></param>
/// <param name="unpremultiply"></param>
/// <param name="edgeAction"></param>
public static void ConvolveAndTranspose(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, bool alpha, bool premultiply, bool unpremultiply, EdgeMode edgeAction)
{
float[] matrix = kernel.GetKernel();
int cols = kernel.Width;
int cols2 = cols / 2;
for (int y = 0; y < height; y++)
{
int index = y;
int ioffset = y * width;
for (int x = 0; x < width; x++)
{
float r = 0, g = 0, b = 0, a = 0;
int moffset = cols2;
for (int col = -cols2; col <= cols2; col++)
{
float f = matrix[moffset + col];
if (f != 0)
{
int ix = x + col;
if (ix < 0)
{
if (edgeAction == EdgeMode.Clamp)
{
ix = 0;
}
else if (edgeAction == EdgeMode.Wrap)
{
ix = (x + width) % width;
}
}
else if (ix >= width)
{
if (edgeAction == EdgeMode.Clamp)
{
ix = width - 1;
}
else if (edgeAction == EdgeMode.Wrap)
{
ix = (x + width) % width;
}
}
int rgb = inPixels[ioffset + ix];
int pa = (rgb >> 24) & 0xff;
int pr = (rgb >> 16) & 0xff;
int pg = (rgb >> 8) & 0xff;
int pb = rgb & 0xff;
if (premultiply)
{
float a255 = pa * (1.0f / 255.0f);
pr = (int)(pr * a255);
pg = (int)(pg * a255);
pb = (int)(pb * a255);
}
a += f * pa;
r += f * pr;
g += f * pg;
b += f * pb;
}
}
if (unpremultiply && a != 0 && a != 255)
{
float f = 255.0f / a;
r *= f;
g *= f;
b *= f;
}
int ia = alpha ? PixelUtils.Clamp((int)(a + 0.5)) : 0xff;
int ir = PixelUtils.Clamp((int)(r + 0.5));
int ig = PixelUtils.Clamp((int)(g + 0.5));
int ib = PixelUtils.Clamp((int)(b + 0.5));
outPixels[index] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
index += height;
}
}
}
private void ResetEdgeMode()
{
EdgeMode = EdgeMode.None;
}
/// <summary>
/// Returns standard deviation of degrees on the provided layers.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor.</param>
/// <param name="layers">HashSet of layers.</param>
/// <param name="edgeMode">In / Out / All, mode of edge.</param>
/// <returns>Standard deviation of degrees.</returns>
public double DegreeDeviation(MultilayerNetwork mnet, Actor actor, HashSet <Layer> layers, EdgeMode edgeMode)
{
mathUtils = MathUtils.Instance; //new MathUtils();
var degrees = new List <double>();
foreach (var layer in layers)
{
degrees.Add(Degree(mnet, actor, layer, edgeMode));
}
return(mathUtils.Stdev(degrees));
}
/**
* Kontruktor pro tridu AutomatEdge.
*
* atribut endState urcuje do ktereho stavu prechod vede
* atribut mode urcuje, zda pokud po hrane prejdeme, tak dochazi k zanorovani, ci vynorovani
* atribut att Type urcuje, jakyho typu je atribut, pro nejz je konstruovana tato hrana
**/
public AutomatEdge(AutomatState endState, EdgeMode mode, AttributeType attType)
{
this.endState = endState;
this.edgeMode = mode;
this.AttributeType = attType;
}
public EdgeModeSymbol(string name, Location location, EdgeMode edgeMode) : base(name, location) {
EdgeMode = edgeMode;
}
