public void FreeLeft()
{
var mm = new MemoryManager(new Ram(10, 1));
var p1 = mm.Allocate(_pcb);
var p2 = mm.Allocate(_pcb);
var p3 = mm.Allocate(_pcb);
mm.Free(p1);
var freePages = mm.FreePages.ToArray();
Assert.That(freePages[0].Offset, Is.EqualTo(0));
Assert.That(freePages[1].Offset, Is.EqualTo(6));
mm.Free(p3);
freePages = mm.FreePages.ToArray();
Assert.That(freePages[0].Offset, Is.EqualTo(0));
Assert.That(freePages[1].Offset, Is.EqualTo(3));
mm.Free(p2);
freePages = mm.FreePages.ToArray();
Assert.That(freePages.Length, Is.EqualTo(1));
Assert.That(freePages[0].Offset, Is.EqualTo(0));
Assert.That(freePages[0].Size, Is.EqualTo(10));
}
public void Free()
{
var mm = new MemoryManager(new Ram(10, 1));
var p1 = mm.Allocate(_pcb);
var p2 = mm.Allocate(_pcb);
var p3 = mm.Allocate(_pcb);
var freeBlock = mm.FreePages.Single();
Assert.That(freeBlock.Offset, Is.EqualTo(6));
Assert.That(freeBlock.Size, Is.EqualTo(4));
}
public void Allocate()
{
var mm = new MemoryManager(new Ram(10, 1));
var p1 = mm.Allocate(_pcb);
var p2 = mm.Allocate(_pcb);
var p3 = mm.Allocate(_pcb);
var allocated = mm.AllocatedPages.ToArray();
Assert.That(allocated.Length, Is.EqualTo(3));
Assert.That(new PageInfo(p1), Is.EqualTo(allocated[0]));
Assert.That(new PageInfo(p2), Is.EqualTo(allocated[1]));
Assert.That(new PageInfo(p3), Is.EqualTo(allocated[2]));
}
/// <inheritdoc />
public override void Blend(MemoryManager memoryManager, Span <TPixel> destination, Span <TPixel> background, Span <TPixel> source, Span <float> amount)
{
Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
using (IBuffer <Vector4> buffer = memoryManager.Allocate <Vector4>(destination.Length * 3, false))
{
Span <Vector4> destinationSpan = buffer.Slice(0, destination.Length);
Span <Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
Span <Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
PixelOperations <TPixel> .Instance.ToVector4(background, backgroundSpan, destination.Length);
PixelOperations <TPixel> .Instance.ToVector4(source, sourceSpan, destination.Length);
for (int i = 0; i < destination.Length; i++)
{
destinationSpan[i] = PorterDuffFunctions.HardLight(backgroundSpan[i], sourceSpan[i], amount[i]);
}
PixelOperations <TPixel> .Instance.PackFromVector4(destinationSpan, destination, destination.Length);
}
}
/// <summary>
/// Constructs a new user-created <see cref="OverlayPlaneGraphic"/> with the specified dimensions.
/// </summary>
/// <param name="rows">The number of rows in the overlay.</param>
/// <param name="columns">The number of columns in the overlay.</param>
protected OverlayPlaneGraphic(int rows, int columns)
{
Platform.CheckPositive(rows, "rows");
Platform.CheckPositive(columns, "columns");
_index = -1;
_frameIndex = 0;
_label = string.Empty;
_description = string.Empty;
_type = OverlayType.G;
_subtype = null;
_source = OverlayPlaneSource.User;
_overlayGraphic = new GrayscaleImageGraphic(
rows, columns, // the reported overlay dimensions
8, // bits allocated is always 8
8, // overlays always have bit depth of 1, but we upconverted the data
7, // the high bit is now 7 after upconverting
false, false, // overlays aren't signed and don't get inverted
1, 0, // overlays have no rescale
MemoryManager.Allocate <byte>(rows * columns)); // new empty pixel buffer
this.Color = System.Drawing.Color.PeachPuff;
base.Graphics.Add(_overlayGraphic);
}
private static byte[] SlabVtkImageData(vtkImageData slabData, Action <IntPtr, byte[], int, int, int, bool> slabAggregator, int bitsPerVoxel, bool signed)
{
// get the pointer to the image data
var pData = slabData.GetScalarPointer();
if (pData.Equals(IntPtr.Zero))
{
return(null);
}
// get number of subsamples and pixels per subsample
var dataDimensions = slabData.GetDimensions();
var subsamplePixels = dataDimensions[0] * dataDimensions[1];
var subsamples = dataDimensions[2];
// compute byte length of slabbed output data
var dataLength = subsamplePixels * slabData.GetScalarSize();
// slab data to managed buffer
var pixelData = MemoryManager.Allocate <byte>(dataLength);
slabAggregator.Invoke(pData, pixelData, subsamples, subsamplePixels, bitsPerVoxel / 8, signed);
return(pixelData);
}
private static byte[] MipPixelDataFromVtkSlab(vtkImageData slabImageData)
{
VtkHelper.StaticInitializationHack();
#if true // Do our own MIP, albeit slowly
int[] sliceDimensions = slabImageData.GetDimensions();
int sliceDataSize = sliceDimensions[0] * sliceDimensions[1];
IntPtr slabDataPtr = slabImageData.GetScalarPointer();
byte[] pixelData = MemoryManager.Allocate <byte>(sliceDataSize * sizeof(short));
// Init with first slice
Marshal.Copy(slabDataPtr, pixelData, 0, sliceDataSize * sizeof(short));
// Walk through other slices, finding maximum
unsafe
{
short *psSlab = (short *)slabDataPtr;
fixed(byte *pbFrame = pixelData)
{
short *psFrame = (short *)pbFrame;
for (int sliceIndex = 1; sliceIndex < sliceDimensions[2]; sliceIndex++)
{
for (int i = 0; i < sliceDataSize - 1; ++i)
{
int slabIndex = sliceIndex * sliceDataSize + i;
if (psSlab[slabIndex] > psFrame[i])
{
psFrame[i] = psSlab[slabIndex];
}
}
}
}
}
return(pixelData);
#else // Ideally we'd use VTK to do the MIP (MinIP, Average...)
vtkVolumeRayCastMIPFunction mip = new vtkVolumeRayCastMIPFunction();
vtkVolumeRayCastMapper mapper = new vtkVolumeRayCastMapper();
mapper.SetVolumeRayCastFunction(mip);
mapper.SetInput(slabImageData);
//TODO: Need to figure out how to use mapper to output vtkImageData
vtkImageAlgorithm algo = new vtkImageAlgorithm();
algo.SetInput(mapper.GetOutputDataObject(0));
using (vtkExecutive exec = mapper.GetExecutive())
{
VtkHelper.RegisterVtkErrorEvents(exec);
exec.Update();
// Note: These report no output port, must have to do something else to get mapper to give us data
//return exec.GetOutputData(0);
return(mapper.GetOutputDataObject(0));
}
#endif
}
/// <summary>
/// Unpacks the overlay data into an 8-bit overlay pixel data buffer.
/// </summary>
/// <returns>The unpacked, 8-bit overlay pixel data buffer.</returns>
public byte[] Unpack()
{
byte[] unpackedPixelData = MemoryManager.Allocate <byte>(_rows * _columns);
Unpack(_rawOverlayData, unpackedPixelData, _offset, unpackedPixelData.Length, _bigEndianWords);
return(unpackedPixelData);
}
public void Allocate(uint count)
{
address = (byte *)MemoryManager.Allocate((uint)count);
length = count;
}
public MemoryBlock(uint length)
{
address = (byte *)MemoryManager.Allocate((uint)length);
this.length = length;
}
private static byte[] AllocatePixelData(int rows, int columns, int bitsPerPixel)
{
return(MemoryManager.Allocate <byte>(rows * columns * bitsPerPixel / 8));
}
internal override void Apply()
{
this.NiNode_ctor = NetScriptFramework.Main.GameInfo.GetAddressOf(68936);
_cachedOffsets = new int[256];
ulong vid = 17693;
int baseOffset = 0x5430;
Events.OnMainMenu.Register(e =>
{
if (this._curPlaceNode == null)
{
var alloc = MemoryManager.Allocate(0x130, 0);
Memory.InvokeCdecl(this.NiNode_ctor, alloc, 0);
this._curPlaceNode = MemoryObject.FromAddress <NiNode>(alloc);
this._curPlaceNode.IncRef();
alloc = MemoryManager.Allocate(0x10, 0);
this._curPlacePos = MemoryObject.FromAddress <NiPoint3>(alloc);
Memory.WriteZero(this._curPlacePos.Address, 0xC);
}
}, 0, 1);
Memory.WriteHook(new HookParameters()
{
Address = NetScriptFramework.Main.GameInfo.GetAddressOf(vid, 0x5CF2 - baseOffset, 0, "0F B6 D9 0F BE C2"),
IncludeLength = 6,
ReplaceLength = 6,
Before = ctx =>
{
TESObjectWEAP weap = null;
Actor actor = null;
int count = ctx.CX.ToUInt8();
try
{
weap = MemoryObject.FromAddress <TESObjectWEAP>(ctx.R12);
}
catch
{
}
try
{
actor = MemoryObject.FromAddress <Actor>(ctx.R15);
}
catch
{
}
int now = count;
_mod(weap, actor, ref now);
if (now > 255)
{
now = 255;
}
if (now != count)
{
ctx.CX = new IntPtr(now);
}
},
});
Memory.WriteHook(new HookParameters()
{
Address = NetScriptFramework.Main.GameInfo.GetAddressOf(vid, 0x603D - baseOffset, 0, "E8"),
IncludeLength = 5,
ReplaceLength = 5,
After = ctx =>
{
TESObjectWEAP weap = null;
Actor actor = null;
int count = ctx.AX.ToUInt8();
try
{
weap = MemoryObject.FromAddress <TESObjectWEAP>(ctx.R12);
}
catch
{
}
try
{
actor = MemoryObject.FromAddress <Actor>(ctx.R15);
}
catch
{
}
int now = count;
_mod(weap, actor, ref now);
if (now > 255)
{
now = 255;
}
if (now != count)
{
ctx.AX = new IntPtr(now);
}
},
});
Memory.WriteHook(new HookParameters()
{
Address = NetScriptFramework.Main.GameInfo.GetAddressOf(42928, 0xB91B - 0xB360, 0, "E8"),
IncludeLength = 5,
ReplaceLength = 5,
After = ctx =>
{
if (settings.ForceDrawTime.Value >= 0.0)
{
ctx.XMM0f = (float)settings.ForceDrawTime.Value;
}
else
{
int track = _projTrack;
if (track > 0)
{
track--;
_projTrack = track;
if (_projStrength.HasValue)
{
ctx.XMM0f = _projStrength.Value;
if (track == 0)
{
_projStrength = null;
}
}
else
{
_projStrength = ctx.XMM0f;
}
}
}
},
});
Memory.WriteHook(new HookParameters()
{
Address = NetScriptFramework.Main.GameInfo.GetAddressOf(vid, 0x621C - baseOffset, 0, "F3 0F 10 44 24 48"),
IncludeLength = 0, //0x3D - 0x1C,
ReplaceLength = 0x3D - 0x1C,
Before = ctx =>
{
var pos = MemoryObject.FromAddress <NiPoint3>(ctx.BP + 0x68);
int index = ctx.SI.ToUInt8();
if (index <= 1)
{
pos.X = Memory.ReadFloat(ctx.SP + 0x48);
pos.Y = Memory.ReadFloat(ctx.SP + 0x4C);
pos.Z = Memory.ReadFloat(ctx.SP + 0x50);
return;
}
var plr = PlayerCharacter.Instance;
bool isPlayer = plr != null && plr.Cast <PlayerCharacter>() == ctx.R15;
if (isPlayer)
{
_projTrack = index;
}
else
{
_projTrack = 0;
}
float x = 0.0f;
float y = 0.0f;
_calculate_projectile_offset(index - 1, ref x, ref y);
if (this._curPlaceHadNode)
{
var npos = this._curPlaceNode.WorldTransform.Position;
npos.X = Memory.ReadFloat(ctx.SP + 0x48);
npos.Y = Memory.ReadFloat(ctx.SP + 0x4C);
npos.Z = Memory.ReadFloat(ctx.SP + 0x50);
this._curPlacePos.X = x;
this._curPlacePos.Y = 0.0f;
this._curPlacePos.Z = y;
this._curPlaceNode.WorldTransform.Translate(this._curPlacePos, npos);
pos.X = npos.X;
pos.Y = npos.Y;
pos.Z = npos.Z;
}
else
{
bool didGet = false;
if (isPlayer)
{
var pcam = PlayerCamera.Instance;
if (pcam != null)
{
var pnode = pcam.Node;
if (pnode != null)
{
byte[] buf = Memory.ReadBytes(pnode.WorldTransform.Address, 0x34);
Memory.WriteBytes(this._curPlaceNode.WorldTransform.Address, buf);
var tpos = this._curPlaceNode.WorldTransform.Position;
tpos.X = Memory.ReadFloat(ctx.SP + 0x48);
tpos.Y = Memory.ReadFloat(ctx.SP + 0x4C);
tpos.Z = Memory.ReadFloat(ctx.SP + 0x50);
this._curPlacePos.X = x;
this._curPlacePos.Y = 0.0f;
this._curPlacePos.Z = y;
this._curPlaceNode.WorldTransform.Translate(this._curPlacePos, pos);
didGet = true;
}
}
}
if (!didGet)
{
pos.X = Memory.ReadFloat(ctx.SP + 0x48) + x;
pos.Y = Memory.ReadFloat(ctx.SP + 0x4C);
pos.Z = Memory.ReadFloat(ctx.SP + 0x50) + y;
}
}
}
});
Events.OnWeaponFireProjectilePosition.Register(e =>
{
if (e.Node != null)
{
byte[] buf = Memory.ReadBytes(e.Node.WorldTransform.Address, 0x34);
Memory.WriteBytes(this._curPlaceNode.WorldTransform.Address, buf);
this._curPlaceHadNode = true;
}
else
{
this._curPlaceHadNode = false;
}
}, 50);
}
public unsafe ComposedLut(IComposableLut[] luts, BufferCache <int> cache, BufferCache <double> doubleCache)
{
//luts.Validate();
int lutCount;
IComposableLut firstLut, lastLut;
GetFirstAndLastLut(luts, out firstLut, out lastLut, out lutCount);
_minInputValue = (int)Math.Round(firstLut.MinInputValue);
_maxInputValue = (int)Math.Round(firstLut.MaxInputValue);
_minOutputValue = (int)Math.Round(lastLut.MinOutputValue);
_maxOutputValue = (int)Math.Round(lastLut.MaxOutputValue);
_length = _maxInputValue - _minInputValue + 1;
_data = cache != null?cache.Allocate(_length) : MemoryManager.Allocate <int>(_length);
const int intermediateDataSize = 8192; // each double entry is 8 bytes so the entire array is 64kB - just small enough to stay off the large object heap
var intermediateData = doubleCache != null?doubleCache.Allocate(intermediateDataSize) : MemoryManager.Allocate <double>(intermediateDataSize);
try
{
fixed(double *intermediateLutData = intermediateData)
fixed(int *composedLutData = _data)
{
var min = _minInputValue;
var max = _maxInputValue + 1;
var pComposed = composedLutData;
// performs the bulk lookups in 64kB chunks (8k entries @ 8 bytes per) in order to keep the intermediate buffer off the large object heap
for (var start = min; start < max; start += intermediateDataSize)
{
var stop = Math.Min(max, start + intermediateDataSize);
var count = stop - start;
var pIntermediate = intermediateLutData;
for (var i = start; i < stop; ++i)
{
*pIntermediate++ = i;
}
for (var j = 0; j < lutCount; ++j)
{
luts[j].LookupValues(intermediateData, intermediateData, count);
}
pIntermediate = intermediateLutData;
for (var i = 0; i < count; ++i)
{
*pComposed++ = (int)Math.Round(*pIntermediate++);
}
}
}
}
finally
{
if (doubleCache != null)
{
doubleCache.Return(intermediateData);
}
}
}
// Builds the volume array. Takes care of Gantry Tilt correction (pads rows at top/bottom accordingly)
private ushort[] BuildVolumeArray(ushort pixelPadValue, double normalizedSlope, double normalizedIntercept, out int minVolumeValue, out int maxVolumeValue)
{
var volumeData = MemoryManager.Allocate <ushort>(VolumeSize.Volume, TimeSpan.FromSeconds(10));
var min = int.MaxValue;
var max = int.MinValue;
float lastFramePos = (float)_frames[_frames.Count - 1].Frame.ImagePositionPatient.Z;
int position = 0;
using (var lutFactory = LutFactory.Create())
{
for (var n = 0; n < _frames.Count; n++)
{
var sourceFrame = _frames[n].Frame;
var frameDimensions = VolumeSize;
var paddingRows = PaddingRows;
var gantryTilt = GantryTilt;
// PadTop takes care of padding rows for gantry tilt correction
int countRowsPaddedAtTop = 0;
if (paddingRows > 0)
{
// figure out how many rows need to be padded at the top
float deltaMm = lastFramePos - (float)sourceFrame.ImagePositionPatient.Z;
double padTopMm = Math.Tan(gantryTilt) * deltaMm;
countRowsPaddedAtTop = (int)(padTopMm / this.VoxelSpacing.Y + 0.5f);
//TODO (cr Oct 2009): verify that IPP of the first image is correct for the volume.
// account for the tilt in negative radians: we start padding from the bottom first in this case
if (gantryTilt < 0)
{
countRowsPaddedAtTop += paddingRows;
}
int stop = position + countRowsPaddedAtTop * frameDimensions.Width;
for (int i = position; i < stop; i++)
{
volumeData[i] = pixelPadValue;
}
position = stop;
}
// Copy frame data
var frameData = sourceFrame.GetNormalizedPixelData();
var frameBitsStored = sourceFrame.BitsStored;
var frameBytesPerPixel = sourceFrame.BitsAllocated / 8;
var frameIsSigned = sourceFrame.PixelRepresentation != 0;
var frameModalityLut = lutFactory.GetModalityLutLinear(frameBitsStored, frameIsSigned, sourceFrame.RescaleSlope, sourceFrame.RescaleIntercept);
int frameMin, frameMax;
CopyFrameData(frameData, frameBytesPerPixel, frameIsSigned, frameModalityLut, volumeData, position, normalizedSlope, normalizedIntercept, out frameMin, out frameMax);
position += frameData.Length / sizeof(ushort);
min = Math.Min(min, frameMin);
max = Math.Max(max, frameMax);
// Finish out any padding left over from PadTop
if (paddingRows > 0) // Pad bottom
{
int stop = position + ((paddingRows - countRowsPaddedAtTop) * frameDimensions.Width);
for (int i = position; i < stop; i++)
{
volumeData[i] = pixelPadValue;
}
position = stop;
}
// update progress
_callback(n, _frames.Count);
}
}
minVolumeValue = min;
maxVolumeValue = max;
return(volumeData);
}
