//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
SpreadMax = SpreadUtils.SpreadMax(FOperand, FOperator /*,FPA,FPM*/);
FOutput.SliceCount = SpreadMax;
var help = new Helpers();
for (int binID = 0; binID < SpreadMax; binID++)
{
int numOperands = FOperand[binID].SliceCount;// + FOperandB[binID].SliceCount;
//{{{VA,FA},{VB,FB},"i"},{{{VC,FC},{VD,FD},"u"},{VE,FE},"u"},"m"};
string operationString = FOperand[binID][0];
for (int operandID = 0; operandID < numOperands - 1; operandID++)
{
operationString = generateOperationString(operationString, FOperand[binID][operandID + 1], operatorsSmallCaps[(int)FOperator[binID]]);
}
FOutput[binID].SliceCount = 1;
FOutput[binID][0] = operationString;
}
}
//called when data for any output pin is requested
public virtual void Evaluate(int SpreadMax)
{
Prepare();
var input = FInputContainer.IOObject;
var output = FOutputContainer.IOObject;
int sMax = SpreadUtils.SpreadMax(input, FSelect);
output.SliceCount = 0;
FFormerSlice.SliceCount = 0;
for (int i = 0; i < sMax; i++)
{
for (int s = 0; s < FSelect[i]; s++)
{
if (s == 0)
{
output.SliceCount++;
output[output.SliceCount - 1].SliceCount = 0;
}
output[output.SliceCount - 1].AddRange(input[i]);
FFormerSlice.Add(i);
}
}
}
public void Evaluate(int spreadMax)
{
if (!FKeyIn.IsChanged && !FCapsIn.IsChanged && !FTimeIn.IsChanged)
{
return;
}
spreadMax = SpreadUtils.SpreadMax(FKeyIn, FCapsIn, FTimeIn);
FSubjects.ResizeAndDispose(spreadMax, slice => new Subject <KeyNotification>());
FOutput.ResizeAndDismiss(spreadMax, slice => new Keyboard(FSubjects[slice], true));
FKeyboardStates.ResizeAndDismiss(spreadMax, () => KeyboardState.Empty);
for (int i = 0; i < spreadMax; i++)
{
var keyboard = FOutput[i];
var keyboardState = new KeyboardState(FKeyIn[i].Cast <Keys>(), FCapsIn[0], FTimeIn[i]);
var previousKeyboardState = FKeyboardStates[i];
if (keyboardState != previousKeyboardState)
{
var subject = FSubjects[i];
var keyDowns = keyboardState.KeyCodes.Except(previousKeyboardState.KeyCodes);
foreach (var keyDown in keyDowns)
{
subject.OnNext(new KeyDownNotification(keyDown, this));
}
var keyUps = previousKeyboardState.KeyCodes.Except(keyboardState.KeyCodes);
foreach (var keyUp in keyUps)
{
subject.OnNext(new KeyUpNotification(keyUp, this));
}
}
FKeyboardStates[i] = keyboardState;
}
}
public void Evaluate(int spreadmax)
{
var changed = InputIsChanged() ||
FOtherBehavs.IsChanged ||
FAdd.IsChanged ||
FRemove.IsChanged ||
FTarget.IsChanged;
FOutput.Stream.IsChanged = false;
//FFlatDate.Stream.IsChanged = false;
if (changed)
{
var slc = Math.Max(SpreadUtils.SpreadMax(FAdd, FRemove, FTarget), Spreadmax());
FOutput.SliceCount = slc;
for (int i = 0; i < slc; i++)
{
if (FOutput[i] == null)
{
FOutput[i] = new SetProgressbarBehavior();
}
FOutput[i].Range = CreateRange(i);
FOutput[i].Add = FAdd[i];
FOutput[i].Remove = FRemove[i];
FOutput[i].WorksheetName = FTarget[i];
}
if (slc > 0)
{
FOutput[0].Others = FOtherBehavs;
}
FOutput.Stream.IsChanged = true;
}
}
private IEnumerable <Tuple <string, string> > GetNamespaces(ISpread <string> prefixes, ISpread <string> namespaces)
{
for (int i = 0; i < SpreadUtils.SpreadMax(prefixes, namespaces); i++)
{
yield return(Tuple.Create(prefixes[i], namespaces[i]));
}
}
void KeyMatchChangedCB(IDiffSpread <string> sender)
{
var keyCodes = KeyMatchConfig[0].ToKeyCodes();
//add new pins
foreach (var keyCode in keyCodes)
{
if (!FColumns.Any(col => col.KeyCode == keyCode))
{
var column = new Column(FIOFactory, keyCode, FScheduler);
FColumns.Add(column);
}
}
//remove obsolete pins
foreach (var column in FColumns.ToArray())
{
if (!keyCodes.Contains(column.KeyCode))
{
FColumns.Remove(column);
column.Dispose();
}
}
var spreadMax = SpreadUtils.SpreadMax(KeyMatchConfig, KeyboardIn, ResetIn, KeyModeIn);
UpdateColumns(spreadMax);
}
public void Evaluate(int SpreadMax)
{
if (_init)
{
DeviceList.Local.Changed += (sender, args) => _devChange = true;
_init = false;
}
if (_devChange || SpreadUtils.AnyChanged(VendorIdIn, ProductIdIn))
{
var sprmax = SpreadUtils.SpreadMax(VendorIdIn, ProductIdIn);
DevicesOut.SliceCount = sprmax;
for (int i = 0; i < sprmax; i++)
{
if (VendorIdIn[i] < 0 || ProductIdIn[i] < 0)
{
var devices = DeviceList.Local.GetHidDevices();
DevicesOut[i].AssignFrom(devices);
}
else
{
var devices = DeviceList.Local.GetHidDevices(VendorIdIn[i], ProductIdIn[i]);
DevicesOut[i].AssignFrom(devices);
}
}
_devChange = false;
}
ChangedOut[0] = _devChange;
}
protected virtual int SliceCount()
{
return(SpreadUtils.SpreadMax(OperationsIn, LoadIn, HardLoadIn, ReloadIn, SizeIn,
DocSizeBaseSelectorIn, AutoWidthIn, AutoHeightIn, PopupIn, FilterUrlIn,
ZoomLevelIn, MouseIn, KeyboardIn, ShowDevToolsIn,
LivePageIn, UserAgentIn, LogToConsoleIn, NoMouseMoveOnFirstTouchIn, EnabledIn));
}
public void Render(DX11RenderContext context, DX11RenderSettings settings)
{
if (this.FEnabled[0])
{
if (this.FLayerIn.IsConnected)
{
var spMax = SpreadUtils.SpreadMax(this.FInWorld, this.FInRelative);
for (int i = 0; i < spMax; i++)
{
Matrix world = settings.WorldTransform;
if (this.FInRelative[i])
{
settings.WorldTransform = settings.WorldTransform * this.FInWorld[i];
}
else
{
settings.WorldTransform = this.FInWorld[i];
}
this.FLayerIn.RenderAll(context, settings);
settings.WorldTransform = world;
}
}
}
else
{
if (this.FLayerIn.IsConnected)
{
this.FLayerIn.RenderAll(context, settings);
}
}
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
SpreadMax = SpreadUtils.SpreadMax(FVec, FTI /*,FPA,FPM*/);
FVecOut.SliceCount = SpreadMax;
var help = new Helpers();
if (FCal[0])
{
for (int binID = 0; binID < SpreadMax; binID++)
{
int entries = FVec[binID].SliceCount;
int entriesXYZ = entries * 3;
int entriesXY = entries * 2;
int numIndices = FTI[binID].SliceCount;
int numTriangles = numIndices / 3;
double[] V = new double[entriesXYZ];
V = help.Vector3DToArray(V, FVec[binID]);
int[] tI = new int[numIndices];
tI = FTI[binID].ToArray();
double[] Vuv = new double[entriesXY];
int[] binSizes = new int[2];
binSizes[0] = entries;
binSizes[1] = numTriangles;
try
{
if ((int)FMode[binID] == 0)
{
doARAPParam(V, tI, binSizes, Vuv);
}
else
{
doLSCMParam(V, tI, binSizes, Vuv);
}
// double[] tTexCoordsArr = new double[entriesXY];
// Marshal.Copy(tTexCoords, tTexCoordsArr, 0, entriesXY);
FVecOut[binID].SliceCount = entries;
for (int i = 0; i < entries; i++)
{
FVecOut[binID][i] = new Vector2D(Vuv[i * 2], Vuv[i * 2 + 1]);
}
// ReleaseMemory(tTexCoords);
}
catch (Exception ex)
{
}
}
}
}
public void Update(DX11RenderContext context)
{
if (shaderSample == null)
{
shaderSample = new DX11ShaderInstance(context, effectSample);
shaderLoad = new DX11ShaderInstance(context, effectLoad);
}
DX11ShaderInstance instance = this.pixelCoords[0] ? shaderLoad : shaderSample;
if (this.mipLevel.SliceCount > 1)
{
instance.SelectTechnique("ConstantLevel");
}
else
{
instance.SelectTechnique("DynamicLevel");
}
int totalCount;
if (this.mipLevel.SliceCount > 1)
{
totalCount = SpreadUtils.SpreadMax(this.coordinates, this.mipLevel);
instance.SetByName("UvCount", this.coordinates.SliceCount);
instance.SetByName("LevelCount", this.mipLevel.SliceCount);
}
else
{
totalCount = this.coordinates.SliceCount;
instance.SetByName("MipLevel", this.mipLevel[0]);
}
this.coordinateBuffer = this.coordinateBuffer.GetOrResize(context.Device, this.coordinates.SliceCount, 8);
this.levelBuffer = this.levelBuffer.GetOrResize(context.Device, this.mipLevel.SliceCount, 4);
this.writeBuffer = this.writeBuffer.GetOrResize(context.Device, totalCount, 16);
this.readbackBuffer = this.readbackBuffer.GetOrResize(context.Device, totalCount, 16);
instance.SetByName("TotalCount", totalCount);
instance.SetByName("uvBuffer", coordinateBuffer.SRV);
if (this.mipLevel.SliceCount > 1)
{
instance.SetByName("uvLevelBuffer", levelBuffer.SRV);
}
instance.SetByName("inputTexture", this.textureInput[0][context].SRV);
instance.SetByName("OutputBuffer", writeBuffer.UAV);
instance.ApplyPass(0);
context.CurrentDeviceContext.CopyResource(this.writeBuffer.Buffer, this.readbackBuffer.Buffer);
}
public void Evaluate(int SpreadMax)
{
if (!this.FFormat.PluginIO.IsConnected)
{
this.FOutput.SliceCount = 0;
return;
}
if (this.apply[0] || this.first)
{
this.FText.Sync();
this.FTextAlign.Sync();
this.FParaAlign.Sync();
this.FMaxHeight.Sync();
this.FMaxWidth.Sync();
this.FFormat.Sync();
this.textStyles.Sync();
//first dispose old outputs
for (int i = 0; i < this.FOutput.SliceCount; i++)
{
if (this.FOutput[i] != null)
{
this.FOutput[i].Dispose();
}
}
var spMax = SpreadUtils.SpreadMax(this.FText, this.FTextAlign, this.FParaAlign, this.FMaxHeight, this.FMaxWidth, this.FFormat, this.textStyles);
//then set new slicecount
this.FOutput.SliceCount = spMax;
//then create new outputs
for (int i = 0; i < spMax; i++)
{
float maxw = this.FMaxWidth[i] > 0.0f ? this.FMaxWidth[i] : 0.0f;
float maxh = this.FMaxHeight[i] > 0.0f ? this.FMaxHeight[i] : 0.0f;
var tl = new TextLayout(this.dwFactory, this.FText[i], this.FFormat[i], maxw, maxh);
var align = (int)this.FTextAlign[i];
tl.TextAlignment = (TextAlignment)align;
tl.ParagraphAlignment = this.FParaAlign[i];
var styles = textStyles[i];
for (int j = 0; j < styles.SliceCount; j++)
{
if (styles[j] != null)
{
styles[j].Apply(tl);
}
}
this.FOutput[i] = tl;
}
}
this.first = false;
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FOutput.SliceCount = SpreadUtils.SpreadMax(FSpread, FInput, FOffset);
for (int i = 0; i < FInput.SliceCount; i++)
{
FOutput[i].AssignFrom(FSpread[i]);
for (int s = 0; s < FInput[i].SliceCount; s++)
{
FOutput[i][s + FOffset[i]] = FInput[i][s];
}
}
}
public void Evaluate(int SpreadMax)
{
if (FWrapper.IsConnected)
{
FOut.SliceCount = FValid.SliceCount = FWrapper.SliceCount;
for (int i = 0; i < FWrapper.SliceCount; i++)
{
var wrapper = FWrapper[i];
if (wrapper == null)
{
FOut[i].SliceCount = FValid[i].SliceCount = 0;
continue;
}
var slc = SpreadUtils.SpreadMax(FObj[i], FFunc[i]);
FOut[i].SliceCount = FValid[i].SliceCount = slc;
for (int j = 0; j < slc; j++)
{
var objname = FObj[i][j];
var funcname = FFunc[i][j];
if (wrapper.JsBindings.ContainsKey(objname))
{
var obj = wrapper.JsBindings[objname];
if (obj.Functions.ContainsKey(funcname))
{
FOut[i][j] = obj.Functions[funcname];
FValid[i][j] = true;
}
else
{
FOut[i][j] = null;
FValid[i][j] = false;
}
}
else
{
FOut[i][j] = null;
FValid[i][j] = false;
}
}
}
}
else
{
FOut.SliceCount = FValid.SliceCount = 0;
}
}
public List <int> Reorder(DX11RenderSettings settings, List <DX11ObjectRenderSettings> objectSettings)
{
internalBuffer.Clear();
int spreadMax = SpreadUtils.SpreadMax(this.FInCount, this.FInIndex);
for (int i = 0; i < spreadMax; i++)
{
int start = this.FInIndex[i];
int count = this.FInCount[i];
for (int j = 0; j < count; j++)
{
internalBuffer.Add(start + j);
}
}
return(this.internalBuffer);
}
private int CalculateSpreadMax()
{
int max = this.varmanager.CalculateSpreadMax();
int spFixed = SpreadUtils.SpreadMax(this.FIn, this.FInTechnique);
if (max == 0 || spFixed == 0)
{
return(0);
}
else
{
max = Math.Max(spFixed, max);
return(max);
}
}
public override void OnEvaluateBegin()
{
base.OnEvaluateBegin();
for (int i = 0; i < FInput.SliceCount; i++)
{
if (FInput[i] == null)
{
continue;
}
var device = FInput[i];
for (int j = 0; j < SpreadUtils.SpreadMax(OutputReportIn[i], SendReportIn[i]); j++)
{
if (SendReportIn[i][j])
{
device.Send(OutputReportIn[i][j]);
}
}
}
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
Prepare();
var spread = FSpreadContainer.IOObject;
var input = FInputContainer.IOObject;
var output = FOutputContainer.IOObject;
output.SliceCount = SpreadUtils.SpreadMax(spread, input, FOffset);
for (int i = 0; i < input.SliceCount; i++)
{
output[i].AssignFrom(spread[i]);
for (int s = 0; s < input[i].SliceCount; s++)
{
output[i][s + FOffset[i]] = input[i][s];
}
}
}
// [Import()]
// public ILogger FLogger;
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
SpreadMax = SpreadUtils.SpreadMax(FYear, FMonth, FDay, FHour, FMinute, FSecond, FMillsecond /*,FPA,FPM*/);
FDateTime.SliceCount = SpreadMax;
for (int binID = 0; binID < SpreadMax; binID++)
{
bool InChange = FYear[binID].IsChanged || FMonth[binID].IsChanged || FDay[binID].IsChanged || FHour[binID].IsChanged || FMinute[binID].IsChanged || FSecond[binID].IsChanged || FMillsecond[binID].IsChanged;
if (InChange)
{
int subCount = SpreadUtils.SpreadMax(FYear[binID], FMonth[binID], FDay[binID], FHour[binID], FMinute[binID], FSecond[binID], FMillsecond[binID] /*,FPA,FPM*/);
FDateTime[binID].SliceCount = subCount;
for (int dateID = 0; dateID < subCount; dateID++)
{
FDateTime[binID][dateID] = new DateTime(FYear[binID][dateID], FMonth[binID][dateID], FDay[binID][dateID], FHour[binID][dateID], FMinute[binID][dateID], FSecond[binID][dateID], FMillsecond[binID][dateID]);
}
}
}
}
//called when data for any output pin is requested
public void Evaluate(int spreadMax)
{
spreadMax = FDirectory.SliceCount
.CombineWith(FFileMask)
.CombineWith(FReload)
.CombineWith(FBufferSize)
.CombineSpreads(FPreloadFrames.SliceCount)
.CombineSpreads(FVisibleFrameId.SliceCount);
FPlayers.ResizeAndDispose(spreadMax, (int slice) => new Player(FDirectory[slice], FFileMask[slice], FMemoryPool, FLogger));
FFrameCount.SliceCount = spreadMax;
FPreloaded.SliceCount = spreadMax;
int texSliceCount = spreadMax.CombineSpreads(SpreadUtils.SpreadMax(FVisibleFrameId as System.Collections.Generic.IEnumerable <ISpread <int> >));
FTextureOutput.Resize(texSliceCount, () => new DX11Resource <DX11ResourceTexture2D>(), (t) => t.Dispose());
FWidth.SliceCount = texSliceCount;
FHeight.SliceCount = texSliceCount;
FLoaded.SliceCount = texSliceCount;
FReadTime.SliceCount = texSliceCount;
FDecodeTime.SliceCount = texSliceCount;
FGPUTime.SliceCount = texSliceCount;
for (int i = 0; i < spreadMax; i++)
{
if (FPlayers[i].DirectoryName != FDirectory[i] || FPlayers[i].FileMask != FFileMask[i] || FReload[i])
{
FPlayers[i].Dispose();
FPlayers[i] = new Player(FDirectory[i], FFileMask[i], FMemoryPool, FLogger);
}
FPlayers[i].BufferSize = FBufferSize[i];
if (FPlayers[i].FrameCount > 0)
{
FPlayers[i].Preload(FPreloadFrames[i]);
}
FFrameCount[i] = FPlayers[i].FrameCount;
FPreloaded[i].AssignFrom(FPlayers[i].Loaded);
}
}
public void Evaluate(int spreadMax)
{
int sMax = SpreadUtils.SpreadMax(FInput, FSelect);
FOutput.SliceCount = 0;
FFormerSlice.SliceCount = 0;
for (int i = 0; i < sMax; i++)
{
for (int s = 0; s < FSelect[i]; s++)
{
if (s == 0)
{
FOutput.SliceCount++;
}
FOutput[FOutput.SliceCount - 1] = FInput[i];
FFormerSlice.Add(i);
}
}
}
public void Evaluate(int spreadmax)
{
var changed = InputIsChanged() ||
FOtherBehavs.IsChanged ||
FFlatString.IsChanged ||
FFlatVals.IsChanged ||
FAutoSet.IsChanged ||
FTarget.IsChanged;
FOutput.Stream.IsChanged = false;
//FFlatDate.Stream.IsChanged = false;
if (changed)
{
var slc = Math.Max(SpreadUtils.SpreadMax(FFlatString, FFlatVals, FTarget), Spreadmax());
FOutput.SliceCount = slc;
for (int i = 0; i < slc; i++)
{
if (FOutput[i] == null || FOutput[i] == FOutput[i - 1])
{
FOutput[i] = new SetCellDataBehavior();
}
FOutput[i].Range = CreateRange(i);
FOutput[i].FlatText = FFlatString[i];
FOutput[i].FlatValue = FFlatVals[i];
FOutput[i].WorksheetName = FTarget[i];
FOutput[i].IsChanged = true;
}
if (slc > 0)
{
FOutput[0].Others = FOtherBehavs;
}
if (FAutoSet[0])
{
FOutput.Stream.IsChanged = true;
}
}
}
//called when data for any output pin is requested
public void Evaluate(int spreadMax)
{
spreadMax = SpreadUtils.SpreadMax(KeyboardIn, KeyMatchesIn);
FSubscriptions.ResizeAndDispose(
spreadMax,
slice =>
{
return(new Subscription <Keyboard, KeyDownNotification>(
keyboard => keyboard.KeyNotifications.OfType <KeyDownNotification>(),
(keyboard, n) =>
{
var pressedKeyCode = n.KeyCode;
var keyMatches = KeyMatchesIn[slice];
var output = Outputs[slice];
for (int i = 0; i < output.SliceCount; i++)
{
var keyCodes = keyMatches[i].ToKeyCodes();
var index = keyCodes.IndexOf(pressedKeyCode);
if (index >= 0)
{
output[i] = index;
}
}
},
FScheduler
));
}
);
Outputs.SliceCount = spreadMax;
for (int i = 0; i < spreadMax; i++)
{
Outputs[i].SliceCount = KeyMatchesIn[i].SliceCount;
FSubscriptions[i].Update(KeyboardIn[i]);
}
//process events
FScheduler.Run();
}
protected override int GetMaxSpreadCount()
{
return(SpreadUtils.SpreadMax(DataSourceIn, CycleModeIn)
.CombineSpreads(base.GetMaxSpreadCount()));
}
protected override int Spreadmax()
{
return(SpreadUtils.SpreadMax(FInput, FQuery));
}
protected override int Spreadmax()
{
return(SpreadUtils.SpreadMax(FInput, FTopRow, FLeftCol, FRowCount, FColCount));
}
protected override int Spreadmax()
{
return(SpreadUtils.SpreadMax(FInput, FCol, FRow));
}
// string importDLL = pathToPlatformDLL();
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
SpreadMax = SpreadUtils.SpreadMax(FVec, FPoly, FNVert, FVI, FFH, FFHI, FFM, FHOI, FRI, FRA, FRVC, FHO, FR, FWriteIn, FFile, FWriteOut /*,FPA,FPM*/);
FPoints.SliceCount = SpreadMax;
FTri.SliceCount = SpreadMax;
FTet.SliceCount = SpreadMax;
FRegAttr.SliceCount = SpreadMax;
FPtMarker.SliceCount = SpreadMax;
FFaceMarker.SliceCount = SpreadMax;
FTetNeighbor.SliceCount = SpreadMax;
// FDebug.SliceCount=SpreadMax;
// FPtAttr.SliceCount=SpreadMax;
if (FCal[0])
{
for (int binID = 0; binID < SpreadMax; binID++)
{
string bhvr = FB[binID];
string fileName = FFile[binID];
int computeNeighbors = Convert.ToInt32(bhvr.Contains("n"));
int computeRegionAttr = Convert.ToInt32(bhvr.Contains("A"));
// //always compute neighbors
// bhvr +="n";
// FDebug[0]=computeRegionAttr;
int entries = FVec[binID].SliceCount;
int entriesXYZ = entries * 3;
int numFacets = FPoly[binID].SliceCount;
int numHoles = FHO[binID];
int numRegions = FR[binID];
int writeIn = Convert.ToInt32(FWriteIn[binID]);
int writeOut = Convert.ToInt32(FWriteOut[binID]);
var help = new Helpers();
double[] V = new double[entriesXYZ];
V = help.Vector3DToArray(V, FVec[binID]);
int[] nP = new int[numFacets];
nP = FPoly[binID].ToArray();
int numVert = FNVert[binID].SliceCount;
int[] nV = new int[numVert];
nV = FNVert[binID].ToArray();
int numFHolesXYZ = FFHI[binID].SliceCount * 3;
double[] FfHI = new double[numFHolesXYZ]; //test
FfHI = help.Vector3DToArray(FfHI, FFHI[binID]);
int numIndices = FVI[binID].SliceCount;
int[] VI = new int[numIndices];
VI = FVI[binID].ToArray();
for (int nInd = 0; nInd < numIndices; nInd++)
{
VI[nInd] += 1; //tetgen expects indices starting at 1
}
//facet marker
int[] FM = new int[numFacets];
help.SpreadToArray(FM, FFM[binID]); //can not use toArray() here, as Slicecount may be smaller than numFacets
//facet holes
int[] FfH = new int[numFacets];
help.SpreadToArray(FfH, FFH[binID]); //can not use toArray() here, as Slicecount may be smaller than numFacets
//hole indicators
int sizeHI = FHOI[binID].SliceCount * 3;
double[] HI = new double[sizeHI];
HI = help.Vector3DToArray(HI, FHOI[binID]);
int sizeRI = FRI[binID].SliceCount * 3;
double[] RI = new double[sizeRI];
RI = help.Vector3DToArray(RI, FRI[binID]);
int sizeRA = FRA[binID].SliceCount;
double[] RA = new double[sizeRA];
RA = FRA[binID].ToArray();
int sizeRVC = FRVC[binID].SliceCount;
double[] RVC = new double[sizeRVC];
RVC = FRVC[binID].ToArray();
//point Markers
int[] PM = new int[entries];
help.SpreadToArray(PM, FPM[binID]); //can not use toArray() here, as Slicecount may be smaller than entries
//point Attributes
double[] PA = new double[entries];
// help.SpreadToArray(PA,FPA[binID]);//can not use toArray() here, as Slicecount may be smaller than entries
int[] binSizes = new int[8];
binSizes[0] = entries;
binSizes[1] = numFacets;
binSizes[2] = numHoles;
binSizes[3] = numRegions;
binSizes[4] = writeIn;
binSizes[5] = writeOut;
binSizes[6] = computeNeighbors;
binSizes[7] = computeRegionAttr;
try
{
IntPtr tet = tetCalculate(bhvr, V, PA, PM, nP, nV, VI, FfH, FfHI, FM, HI, RI, RA, RVC, binSizes, fileName);
int size = 5;
int[] tetArr = new int[size];
Marshal.Copy(tet, tetArr, 0, size);
int nOfPoints = tetArr[0];
int nOfFaces = tetArr[1];
int nOfTet = tetArr[2];
int nOfTetAttr = tetArr[3];
int nOfPointAttr = tetArr[4];
int nOfTriIndices = nOfFaces * 3;
int nOfTetIndices = nOfTet * 4;
double[] _vertXYZ = new double[nOfPoints * 3];
int[] _triIndices = new int[nOfTriIndices];
int[] _tetIndices = new int[nOfTetIndices];
double[] _regionAttr = new double[nOfTet];
int[] _pointMarker = new int[nOfPoints];
int[] _faceMarker = new int[nOfFaces];
int[] _pointAttr = new int[nOfPoints];
int[] _neighborList = new int[nOfTetIndices];
FPoints[binID].SliceCount = nOfPoints;
// FPtAttr[binID].SliceCount = nOfPoints*nOfPointAttr;
FTri[binID].SliceCount = nOfTriIndices;
FTet[binID].SliceCount = nOfTetIndices;
FPtMarker[binID].SliceCount = nOfPoints;
FFaceMarker[binID].SliceCount = nOfFaces;
getValues(_vertXYZ, _triIndices, _tetIndices, _regionAttr, _pointMarker, _faceMarker, _pointAttr, _neighborList);
for (int i = 0; i < nOfPoints; i++)
{
FPoints[binID][i] = new Vector3D(_vertXYZ[i * 3], _vertXYZ[i * 3 + 1], _vertXYZ[i * 3 + 2]);
FPtMarker[binID][i] = _pointMarker[i];
// for (int j = 0; j < nOfPointAttr; j++){ //more than 1 attribute possible? what for?
// FPtAttr[binID][i]= _pointAttr[i];
// }
}
for (int i = 0; i < nOfFaces; i++)
{
for (int j = 0; j < 3; j++)
{
FTri[binID][i * 3 + j] = _triIndices[i * 3 + j] - 1;
}
FFaceMarker[binID][i] = _faceMarker[i];
}
for (int i = 0; i < nOfTet; i++)
{
if (computeRegionAttr > 0)
{
FRegAttr[binID].SliceCount = nOfTet * nOfTetAttr;
for (int j = 0; j < nOfTetAttr; j++) //more than 1 attribute possible? what for?
{
FRegAttr[binID][i] = _regionAttr[i];
}
}
else
{
FRegAttr[binID].SliceCount = 0;
}
for (int j = 0; j < 4; j++)
{
FTet[binID][i * 4 + j] = _tetIndices[i * 4 + j] - 1;
if (computeNeighbors > 0)
{
FTetNeighbor[binID].SliceCount = nOfTetIndices;
FTetNeighbor[binID][i * 4 + j] = _neighborList[i * 4 + j] - 1;
}
else
{
FTetNeighbor[binID].SliceCount = 0;
}
}
}
ReleaseMemory(tet);
}
catch (Exception ex)
{
}
finally
{
}
}
}
//FLogger.Log(LogType.Debug, "hi tty!");
}
protected virtual int GetMaxSpreadCount()
{
return(SpreadUtils.SpreadMax(EnabledIn, IndexIn));
}
// this is the straight forward implementation of the kabsch algorithm.
// see http://en.wikipedia.org/wiki/Kabsch_algorithm for a detailed explanation.
public void Evaluate(int SpreadMax)
{
int newSpreadMax = SpreadUtils.SpreadMax(FInputQ, FInputP);
FOutput.SliceCount = newSpreadMax;
Matrix4x4 mOut;
if (FInputEnabled[0])
{
for (int slice = 0; slice < newSpreadMax; slice++)
{
// ======================== STEP 1 ========================
// translate both sets so that their centroids coincides with the origin
// of the coordinate system.
double[] meanP = new double[3] {
0.0, 0.0, 0.0
}; // mean of first point set
for (int i = 0; i < FInputP[slice].SliceCount; i++)
{
meanP[0] += FInputP[slice][i].x;
meanP[1] += FInputP[slice][i].y;
meanP[2] += FInputP[slice][i].z;
}
meanP[0] /= FInputP[slice].SliceCount;
meanP[1] /= FInputP[slice].SliceCount;
meanP[2] /= FInputP[slice].SliceCount;
double[][] centroidP = new double[3][] { new double[] { meanP[0] }, new double[] { meanP[1] }, new double[] { meanP[2] } };
GeneralMatrix mCentroidP = new GeneralMatrix(centroidP);
double[][] arrayP = new double[FInputP[slice].SliceCount][];
for (int i = 0; i < FInputP[slice].SliceCount; i++)
{
arrayP[i] = new double[3];
arrayP[i][0] = FInputP[slice][i].x - meanP[0]; // subtract the mean values from the incoming pointset
arrayP[i][1] = FInputP[slice][i].y - meanP[1];
arrayP[i][2] = FInputP[slice][i].z - meanP[2];
}
// this is the matrix of the first pointset translated to the origin of the coordinate system
GeneralMatrix P = new GeneralMatrix(arrayP);
double[] meanQ = new double[3] {
0.0, 0.0, 0.0
}; // mean of second point set
for (int i = 0; i < FInputQ[slice].SliceCount; i++)
{
meanQ[0] += FInputQ[slice][i].x;
meanQ[1] += FInputQ[slice][i].y;
meanQ[2] += FInputQ[slice][i].z;
}
meanQ[0] /= FInputQ[slice].SliceCount;
meanQ[1] /= FInputQ[slice].SliceCount;
meanQ[2] /= FInputQ[slice].SliceCount;
double[][] centroidQ = new double[3][] { new double[] { meanQ[0] }, new double[] { meanQ[1] }, new double[] { meanQ[2] } };
GeneralMatrix mCentroidQ = new GeneralMatrix(centroidQ);
double[][] arrayQ = new double[FInputQ[slice].SliceCount][];
for (int i = 0; i < FInputQ[slice].SliceCount; i++)
{
arrayQ[i] = new double[3];
arrayQ[i][0] = FInputQ[slice][i].x - meanQ[0]; // subtract the mean values from the incoming pointset
arrayQ[i][1] = FInputQ[slice][i].y - meanQ[1];
arrayQ[i][2] = FInputQ[slice][i].z - meanQ[2];
}
// this is the matrix of the second pointset translated to the origin of the coordinate system
GeneralMatrix Q = new GeneralMatrix(arrayQ);
// ======================== STEP2 ========================
// calculate a covariance matrix A and compute the optimal rotation matrix
GeneralMatrix A = P.Transpose() * Q;
SingularValueDecomposition svd = A.SVD();
GeneralMatrix U = svd.GetU();
GeneralMatrix V = svd.GetV();
// calculate determinant for a special reflexion case.
double det = (V * U.Transpose()).Determinant();
double[][] arrayD = new double[3][] { new double[] { 1, 0, 0 },
new double[] { 0, 1, 0 },
new double[] { 0, 0, 1 } };
arrayD[2][2] = det < 0 ? -1 : 1; // multiply 3rd column with -1 if determinant is < 0
GeneralMatrix D = new GeneralMatrix(arrayD);
// now we can compute the rotation matrix:
GeneralMatrix R = V * D * U.Transpose();
// ======================== STEP3 ========================
// calculate the translation:
GeneralMatrix T = mCentroidP - R.Inverse() * mCentroidQ;
// ================== OUTPUT TRANSFORM ===================
mOut.m11 = (R.Array)[0][0];
mOut.m12 = (R.Array)[0][1];
mOut.m13 = (R.Array)[0][2];
mOut.m14 = 0;
mOut.m21 = (R.Array)[1][0];
mOut.m22 = (R.Array)[1][1];
mOut.m23 = (R.Array)[1][2];
mOut.m24 = 0;
mOut.m31 = (R.Array)[2][0];
mOut.m32 = (R.Array)[2][1];
mOut.m33 = (R.Array)[2][2];
mOut.m34 = 0;
mOut.m41 = (T.Array)[0][0];
mOut.m42 = (T.Array)[1][0];
mOut.m43 = (T.Array)[2][0];
mOut.m44 = 1;
FOutput[slice] = mOut;
}
}
}
