public override void Process()
{
if (FInput.ImageAttributes.ChannelCount == 1)
{
if (!FInput.LockForReading())
{
return;
}
try
{
Compare(FInput.CvMat);
}
finally
{
FInput.ReleaseForReading();
}
}
else
{
FInput.GetImage(Buffer);
Compare(Buffer.CvMat);
}
if (FPassOriginal)
{
FOutput.Image.SetImage(FInput.Image);
}
if (FPassOriginal)
{
CvInvoke.cvNot(Buffer.CvMat, Buffer.CvMat);
CvInvoke.cvSet(FOutput.Image.CvMat, new MCvScalar(0.0), Buffer.CvMat);
FOutput.Send();
}
else
{
FOutput.Send(Buffer);
}
}
public override void Evaluate(int SpreadMax)
{
if (!FInput.IsChanged && !FTcpKeepAlive.IsChanged && !FTcpKeepAliveIdle.IsChanged && !FTcpKeepAliveInterval.IsChanged)
{
return;
}
FOutput.SliceCount = SpreadMax;
// var Default = Options.Default();
for (int i = 0; i < SpreadMax; i++)
{
var config = new Options(FInput[i]);
config.TcpKeepalive = FTcpKeepAlive[i];
config.TcpKeepaliveIdle = FTcpKeepAliveIdle[i];
config.TcpKeepaliveInterval = FTcpKeepAliveInterval[i];
FOutput[i] = config;
}
FOutput.Flush();
}
public void Reload()
{
try
{
if (FWidth < 1)
{
throw (new Exception("Width < 1"));
}
if (FHeight < 1)
{
throw (new Exception("Height < 1"));
}
if (FFormat == null)
{
throw (new Exception("No valid format selected"));
}
if (FInput == null)
{
throw (new Exception("No input stream selected"));
}
if (FInput.Length == 0)
{
throw (new Exception("Input stream empty"));
}
byte[] data = new byte[FInput.Length];
FInput.Read(data, 0, (int)FInput.Length);
FOutput.Image.Initialise(new Size(FWidth, FHeight), FFormat);
FOutput.Image.SetPixels(data);
FOutput.Send();
Status = "OK";
}
catch (Exception e)
{
Status = e.Message;
}
}
protected override void Generate()
{
GetPixels();
FOutput.Send();
}
public void Refresh()
{
FOutput.Image.Initialise(FSize, TColorFormat.RGBA32F);
FillRandomValues();
FOutput.Send();
}
//called when data for any output pin is requested
public override void Evaluate(int SpreadMax)
{
//check transforms
if (FTransformIn.IsChanged)
{
//assign size and clear group list
FOutput.SliceCount = FTransformIn.SliceCount;
FGroups.Clear();
//create groups and add matrix to it
for (int i = 0; i < FTransformIn.SliceCount; i++)
{
var g = new SvgGroup();
g.Transforms = new SvgTransformCollection();
var m = FTransformIn[i];
var mat = new SvgMatrix(new List <float>()
{
m.M11, m.M12, m.M21, m.M22, m.M41, m.M42
});
g.Transforms.Add(mat);
FGroups.Add(g);
}
}
//add all elements to each group
var pinsChanged = FInput.IsChanged || FTransformIn.IsChanged || FEnabledIn.IsChanged;
if (pinsChanged)
{
foreach (var g in FGroups)
{
g.Children.Clear();
if (FEnabledIn[0])
{
for (int i = 0; i < FInput.SliceCount; i++)
{
var pin = FInput[i];
for (int j = 0; j < pin.SliceCount; j++)
{
var elem = pin[j];
if (elem != null)
{
g.Children.AddAndFixID(elem, true, true, LogIDFix);
}
}
}
}
}
//write groups to output
FOutput.AssignFrom(FGroups);
}
//set id and class to elements
if (pinsChanged || FIDIn.IsChanged || FClassIn.IsChanged)
{
base.SetIDs();
}
}
public override void Process()
{
FInput.GetImage(FOutput.Image);
FOutput.Send();
}
public override void Process()
{
FInput.GetImage(FGrayscale);
CvInvoke.cvCanny(FGrayscale.CvMat, FOutput.CvMat, ThresholdMin, ThresholdMax, FAperture);
FOutput.Send();
}
//called when data for any output pin is requested
public override void Evaluate(int SpreadMax)
{
var update = CheckReset();
// early sync only, when not interested in input changes
if (!ManageAllChanges && UpKeep(update))
{
update = true;
}
if (!FInput.IsAnyInvalid() && FInput.IsChanged)
{
foreach (var message in FInput)
{
var found = MatchOrInsert(message);
if (found != null)
{
update = true;
}
}
}
if (RemoveOld())
{
update = true;
}
if (ManageAllChanges)
{
if (UpKeep(update))
{
update = true;
}
}
else
{
var change = Keep.Sync(); // not interested input changes, so sync right away
if (change != null && change.Count() > 0)
{
update = true;
}
if (update)
{
FOutput.FlushResult(Keep);
FCountOut.FlushInt(Keep.Count);
}
}
// add all additional id fields to the changed message
if (update && !Keep.QuickMode)
{
SpreadMax = FChangeOut.SliceCount;
for (int i = 0; i < SpreadMax; i++)
{
var change = FChangeOut[i];
var orig = Keep[FChangeIndexOut[i]];
var idFields = from fieldName in FUseAsID
select fieldName.Name;
foreach (var field in idFields)
{
if (field != TOPIC)
{
change.AssignFrom(field, orig[field]);
}
}
}
}
}
public override void Evaluate(int SpreadMax)
{
InitDX11Graph();
#region early break
if (
!FInput.IsChanged &&
!FConfig.IsChanged &&
!FKey.IsChanged &&
!FAvoidNil.ToISpread().IsChanged &&
!FAvoidNilEnable.IsChanged &&
!FSwapDim.IsChanged
)
{
return;
}
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
if (SpreadMax == 0)
{
if (!FAvoidNilEnable.IsAnyInvalid() && FAvoidNilEnable[0])
{
var force = FAvoidNil.ToISpread().IsChanged || FAvoidNilEnable.IsChanged;
if (force || FOutput.SliceCount > 0) // zero inputs -> zero outputs.
{
FOutput.FlushNil();
// set a default
FBinSize.SliceCount = 1;
FBinSize[0] = 1;
FBinSize.Flush();
FValue.ToISpread().SliceCount = 1;
var output = (FValue.ToISpread())[0] as ISpread;
var dummies = GetDefaults(FAvoidNil.ToISpread(), 0).ToList();
output.SliceCount = dummies.Count;
for (int j = 0; j < dummies.Count; j++)
{
output[j] = dummies[j];
}
FValue.ToISpread().Flush();
return;
}
else
{
return; // already defaulted
}
}
else
{
var force = !FAvoidNilEnable.IsAnyInvalid() && !FAvoidNilEnable[0] && FAvoidNilEnable.IsChanged;
if (force || FOutput.SliceCount > 0) // zero inputs -> zero outputs.
{
FOutput.FlushNil();
FBinSize.SliceCount = 1;
FBinSize[0] = 0;
FBinSize.Flush();
FValue.ToISpread().FlushNil();
return;
}
else
{
return; // already zero'ed
}
}
}
#endregion early break
FOutput.FlushResult(FInput);
var keyCount = FKey.SliceCount;
FBinSize.SliceCount = SpreadMax;
var binnedOutput = FValue.ToISpread();
binnedOutput.SliceCount = SpreadMax * keyCount;
if (!FSwapDim.IsAnyInvalid() && FSwapDim[0]) // fields first
{
for (int i = 0; i < keyCount; i++)
{
var fieldName = FKey[i];
var count = 0;
var index = 0;
foreach (var message in FInput)
{
var output = (binnedOutput[i * keyCount + index] as ISpread);
SetData(message, index, fieldName, output);
count += output.SliceCount;
index++;
}
FBinSize[i] = count;
}
}
else // messages first
{
for (int i = 0; i < SpreadMax; i++)
{
Message message = FInput[i];
var count = 0;
var index = 0;
foreach (var fieldName in FKey)
{
var output = (binnedOutput[i * keyCount + index] as ISpread);
SetData(message, index, fieldName, output);
count += output.SliceCount;
index++;
}
FBinSize[i] = count;
}
}
binnedOutput.Flush();
FBinSize.Flush();
}
private void LoadImage()
{
try
{
if (!System.IO.File.Exists(FFilename))
{
throw (new Exception("Given filename '" + FFilename + "' is not a file"));
}
FREE_IMAGE_FORMAT format = FreeImage.GetFileType(FFilename, 0);
FIBITMAP bmp = FreeImage.Load(format, FFilename, FREE_IMAGE_LOAD_FLAGS.JPEG_ACCURATE);
if (bmp.IsNull == true)
{
throw (new Exception("Couldn't load file"));
}
if (FreeImage.GetColorType(bmp) == FREE_IMAGE_COLOR_TYPE.FIC_PALETTE || FreeImage.GetBPP(bmp) < 8)
{
FIBITMAP converted;
//we need some conversion from strange pallettes
if (FreeImage.IsTransparent(bmp))
{
converted = FreeImage.ConvertTo32Bits(bmp);
}
else if (FreeImage.IsGreyscaleImage(bmp))
{
converted = FreeImage.ConvertTo8Bits(bmp);
}
else
{
converted = FreeImage.ConvertTo24Bits(bmp);
}
FreeImage.Unload(bmp);
bmp = converted;
}
//now we should have a fairly sensible 8, 24 or 32bit (uchar) image
//or a float / hdr image
uint width = FreeImage.GetWidth(bmp);
uint height = FreeImage.GetHeight(bmp);
uint bpp = FreeImage.GetBPP(bmp);
FREE_IMAGE_TYPE type = FreeImage.GetImageType(bmp);
TColorFormat CVFormat;
if (type == FREE_IMAGE_TYPE.FIT_BITMAP)
{
//standard image (8bbp)
uint channels = bpp / 8;
switch (channels)
{
case (1):
CVFormat = TColorFormat.L8;
break;
case (3):
CVFormat = TColorFormat.RGB8;
break;
case (4):
CVFormat = TColorFormat.RGBA8;
break;
default:
CVFormat = TColorFormat.UnInitialised;
break;
}
}
else
{
switch (type)
{
case (FREE_IMAGE_TYPE.FIT_INT16):
CVFormat = TColorFormat.L16;
break;
case (FREE_IMAGE_TYPE.FIT_FLOAT):
CVFormat = TColorFormat.L32F;
break;
case (FREE_IMAGE_TYPE.FIT_INT32):
CVFormat = TColorFormat.L32S;
break;
case (FREE_IMAGE_TYPE.FIT_RGBF):
CVFormat = TColorFormat.RGB32F;
break;
case (FREE_IMAGE_TYPE.FIT_RGBAF):
CVFormat = TColorFormat.RGBA32F;
break;
default:
CVFormat = TColorFormat.UnInitialised;
break;
}
}
if (CVFormat == TColorFormat.UnInitialised)
{
FreeImage.Unload(bmp);
throw (new Exception("VVVV.Nodes.OpenCV doesn't support this colour type \"" + type.ToString() + "\" yet. Please ask!"));
}
IntPtr data = FreeImage.GetBits(bmp);
FOutput.Image.Initialise(new Size((int)width, (int)height), CVFormat);
FOutput.Image.SetPixels(data);
ImageUtils.FlipImageVertical(FOutput.Image);
FOutput.Send();
FreeImage.Unload(bmp);
Status = "OK";
}
catch (Exception e)
{
Status = e.Message;
}
}
public override void Evaluate(int SpreadMax)
{
if (!FInput.IsChanged && !FConfig.IsChanged && !FKey.IsChanged && !FAvoidNil.IsChanged)
{
return;
}
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
if (SpreadMax == 0)
{
if (FOutput.SliceCount > 0) // zero inputs -> zero outputs.
{
FOutput.FlushNil();
FBinSize.SliceCount = 1;
FBinSize[0] = 0;
FBinSize.Flush();
FValue.ToISpread().FlushNil();
return;
}
else
{
return; // already zero'ed
}
}
FOutput.FlushResult(FInput);
var keyCount = FKey.SliceCount;
FBinSize.SliceCount = SpreadMax;
var input = FValue.ToISpread();
input.SliceCount = SpreadMax * keyCount;
for (int i = 0; i < SpreadMax; i++)
{
Message message = FInput[i];
var count = 0;
var index = 0;
foreach (var key in FKey)
{
var type = TargetDynamicType;
var output = (input[i * keyCount + index] as ISpread);
output.SliceCount = 0;
if (!message.Fields.Contains(key))
{
if (!FAvoidNil.IsAnyInvalid() && FAvoidNil[0])
{
output.SliceCount = 1;
output[0] = TypeIdentity.Instance.NewDefault(type);
}
}
else
{
var inputBin = message[key];
if (type.IsAssignableFrom(inputBin.GetInnerType()))
{
output.SliceCount = inputBin.Count;
for (int j = 0; j < inputBin.Count; j++)
{
output[j] = inputBin[j];
}
}
else // will throw Exception, if Conversion is not possible
{
output.SliceCount = inputBin.Count;
for (int j = 0; j < inputBin.Count; j++)
{
output[j] = Convert.ChangeType(inputBin[j], type, CultureInfo.InvariantCulture);
}
}
}
count += output.SliceCount;
index++;
}
FBinSize[i] = count;
}
input.Flush();
FBinSize.Flush();
}
public override void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid())
{
FOutput.FlushNil();
return; // if no input, no further calculation.
}
bool doFlush = false;
// any of the update slices is true -> update the plugin.
var anyUpdate = FUpdate.Any();
// Flush upstream changes through the plugin
if (FInput.IsChanged)
{
FOutput.SliceCount = 0;
FOutput.AssignFrom(FInput);
doFlush = true;
}
else if (!anyUpdate)
{
return;
}
var keyCount = FKey.SliceCount;
var ValueSpread = FValue.ToISpread();
bool newData = ValueSpread.IsChanged; // changed pin
newData |= !FAutoSense[0]; // assume newData, if AutoSense is off.
if (anyUpdate && newData)
{
SpreadMax = FInput.SliceCount;
doFlush = true;
for (int i = 0; i < SpreadMax; i++)
{
Message message = FInput[i];
var keyIndex = 0;
foreach (var key in FKey)
{
var fieldIndex = i * keyCount + keyIndex;
keyIndex++;
if (!FUpdate[fieldIndex])
{
continue;
}
if (!message.Fields.Contains(key))
{
message[key] = BinFactory.New(TargetDynamicType);
}
var value = ValueSpread[fieldIndex] as ISpread;
if (value.SliceCount > 0)
{
if (message[key].GetInnerType().IsAssignableFrom(TargetDynamicType))
{
// check if any relevant change occurred
if (!message[key].Equals(value as IEnumerable))
{
message.AssignFrom(key, value);
}
}
else
{
var casted = from slice in value as IEnumerable <object>
let targetType = message[key].GetInnerType()
select Convert.ChangeType(slice, targetType);
if (!message[key].Equals(casted))
{
message.AssignFrom(key, casted);
}
}
}
else
{
message[key].Clear();
}
}
}
}
if (doFlush)
{
FOutput.Flush();
}
}
public override void Evaluate(int SpreadMax)
{
InitDX11Graph();
if (FInput.IsAnyInvalid())
{
FOutput.FlushNil();
return; // if no input, no further calculation.
}
bool doFlush = false;
// any of the update slices is true -> update the plugin.
var anyUpdate = FUpdate.Any();
// Flush upstream changes through the plugin
if (FInput.IsChanged)
{
FOutput.SliceCount = 0;
FOutput.AssignFrom(FInput);
doFlush = true;
}
else if (!anyUpdate)
{
return;
}
var dataSpread = FValue.ToISpread();
bool newData = dataSpread.IsChanged; // changed pin
newData |= FForce[0]; // assume newData, if AutoSense is off.
if (anyUpdate && newData)
{
// Update and Force not included in spreading.
SpreadMax = dataSpread.SliceCount.CombineWith(FKey).CombineWith(FInput);
if (FUpdate.IsAnyInvalid() || FForce.IsAnyInvalid())
{
SpreadMax = 0;
}
FIterations[0] = SpreadMax;
doFlush = true;
var fieldIndex = 0;
for (int i = 0; i < SpreadMax; i++) // iterate spreaded (except update, which gets cut short)
{
Message message = FInput[i];
for (int j = 0; j < FKey[i].SliceCount; j++, fieldIndex++) // iterate all relevant fields for each message
{
if (!FUpdate[fieldIndex])
{
continue; // update is per-field
}
var key = FKey[i][j];
var spread = dataSpread[fieldIndex] as ISpread;
LazyInsert(message, key, spread);
}
}
}
if (doFlush)
{
FOutput.Flush();
}
}
public override void Process()
{
//we have an integer number of steps
int anticlockwiseSteps = VVVV.Utils.VMath.VMath.Zmod(Rotations, 4);
bool transpose = anticlockwiseSteps % 2 == 1;
Size outputSize = transpose ? new Size(FInput.Image.Size.Height, FInput.Image.Size.Width) : FInput.Image.Size;
if (FOutput.Image.Size != outputSize || FOutput.Image.NativeFormat != FInput.Image.NativeFormat)
{
FOutput.Image.Initialise(outputSize, FInput.Image.NativeFormat);
}
switch (anticlockwiseSteps)
{
case 0:
FInput.GetImage(FOutput.Image);
break;
case 1:
if (FInput.LockForReading())
{
try
{
CvInvoke.cvTranspose(FInput.CvMat, FOutput.CvMat);
}
finally
{
FInput.ReleaseForReading();
}
CvInvoke.cvFlip(FOutput.CvMat, FOutput.CvMat, FLIP.VERTICAL);
}
break;
case 2:
if (FInput.LockForReading())
{
try
{
CvInvoke.cvFlip(FInput.CvMat, FOutput.CvMat, FLIP.HORIZONTAL);
}
finally
{
FInput.ReleaseForReading();
}
CvInvoke.cvFlip(FOutput.CvMat, FOutput.CvMat, FLIP.VERTICAL);
}
break;
case 3:
if (FInput.LockForReading())
{
try
{
CvInvoke.cvTranspose(FInput.CvMat, FOutput.CvMat);
}
finally
{
FInput.ReleaseForReading();
}
CvInvoke.cvFlip(FOutput.CvMat, FOutput.CvMat, FLIP.HORIZONTAL);
}
break;
}
FOutput.Send();
}
