// TODO: Avoid using SetPixel (since it takes out a lock on the image, changes pixel, unlocks.
// This is super slow and we can just take out the lock once. Also there's a bunch of stuff we're doing
// in the inner loop which we can just do up front.
// Example code so I remember what to try again:
// var bmpData = slice.LockBits(new Rectangle(0, 0, slice.Width, slice.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
// unsafe
// {
// var u = (int*)bmpData.Scan0;
// ...
// }
// slick.UnlockBits(bmpData);
public Bitmap GetSlice(int sliceIndex, SliceType sliceType)
{
if (Header.dim == null)
{
throw new NullReferenceException("Nifti file header dim is null");
}
if (Header.dim.Length < 8 ||
Header.dim[0] < 3 ||
Header.dim[1] < 1 || Header.dim[2] < 1 || Header.dim[3] < 1)
{
throw new NullReferenceException("Nifti file header dim 0,1,2,3 are not valid");
}
GetDimensions(sliceType, out var width, out var height, out var nSlices);
if (sliceIndex >= nSlices)
{
throw new ArgumentOutOfRangeException($"Slice index out of range. No of slices = {nSlices}");
}
var slice = new Bitmap(width, height);
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
//var color = Color.FromArgb(GetPixelColor(x, y, sliceIndex, sliceType)).SwapRedBlue();
slice.SetPixel(x, y, Color.FromArgb(GetPixelColor(x, y, sliceIndex, sliceType)));
}
}
//var bmp = new Bitmap(slice.Bitmap);
//slice.Dispose();
return(slice);
}
public void GetDimensions(SliceType sliceType, out int width, out int height, out int nSlices)
{
switch (sliceType)
{
case SliceType.Sagittal:
width = Header.dim[2];
height = Header.dim[3];
nSlices = Header.dim[1];
break;
case SliceType.Coronal:
width = Header.dim[1];
height = Header.dim[3];
nSlices = Header.dim[2];
break;
case SliceType.Axial:
width = Header.dim[1];
height = Header.dim[2];
nSlices = Header.dim[3];
break;
default:
throw new ArgumentOutOfRangeException(nameof(sliceType), sliceType, null);
}
}
private static bool DicomFilesInRightOrder(string dicomFolderPath, SliceType sliceType)
{
var dicomFileWithLowestInstanceNo = GetDicomFileWithLowestInstanceNumber(dicomFolderPath);
if (dicomFileWithLowestInstanceNo == null || string.IsNullOrEmpty(dicomFileWithLowestInstanceNo))
{
throw new Exception($"Failed to get the dicom file with lowest instance number in folder [{dicomFolderPath}]");
}
var headers = GetDicomTags(dicomFileWithLowestInstanceNo);
if (headers == null)
{
throw new Exception($"Failed to get dicom headers for dicom file [{dicomFileWithLowestInstanceNo}]");
}
var imagePosition = headers.ImagePositionPatient.Values;
if (imagePosition.Length < 3)
{
return(true); // disregard
}
var slicesFromLeftToRight = float.Parse(imagePosition[0]) > 0;
var slicesFromBackToFront = float.Parse(imagePosition[1]) > 0;
var slicesFromBottomToTop = float.Parse(imagePosition[2]) < 0;
switch (sliceType)
{
case SliceType.Sagittal when !slicesFromLeftToRight:
case SliceType.Coronal when !slicesFromBackToFront:
case SliceType.Axial when !slicesFromBottomToTop:
return(false); // So later we reverse the order of files
default:
return(true);
}
}
public override int GetVoxelIndex(int x, int y, int z, SliceType sliceType)
{
if (Header.dim[1] == 0 || Header.dim[2] == 0 || Header.dim[3] == 0)
{
throw new Exception("Nifti header dimensions not set!");
}
var ltRt = Header.dim[1];
var antPos = Header.dim[2];
var infSup = Header.dim[3];
// TODO : This is the problem with having a header that doesn't reflect our
// data storage in memory. We should be able to index in based on the header.
switch (sliceType)
{
case SliceType.Axial:
return((ltRt - 1 - x) + ltRt * (antPos - 1 - y) + ltRt * antPos * z);
case SliceType.Sagittal:
return(z + ltRt * (antPos - 1 - x) + ltRt * antPos * (infSup - 1 - y));
case SliceType.Coronal:
return((ltRt - 1 - x) + ltRt * z + ltRt * antPos * (infSup - 1 - y));
default:
throw new Exception("Slice Type not supported");
}
}
public void Create()
{
rotate = true;
this.type = (SliceType)Random.Range(0, 2);
this.sprite.transform.rotation = Quaternion.identity;
GameObject firstLine = Instantiate(linePrefab, transform.position, Quaternion.identity, transform);
GameObject secondLine = Instantiate(linePrefab, transform.position, Quaternion.identity, transform);
first = firstLine.GetComponent <SlicerLine>();
second = secondLine.GetComponent <SlicerLine>();
if (this.type == SliceType.CORNER)
{
this.sprite.sprite = corner;
first.Create(LineDirection.UP, this);
second.Create(LineDirection.RIGHT, this);
}
else
{
this.sprite.sprite = straight;
first.Create(LineDirection.LEFT, this);
second.Create(LineDirection.RIGHT, this);
}
int rotateTime = Random.Range(0, 4);
for (int i = 0; i < rotateTime; i++)
{
Rotate();
}
}
/// <summary>
/// Iterates the section until a top or bottom slice (as specified)
/// is of requested area.
/// </summary>
/// <param name="Area"></param>
/// <param name="sliceType"></param>
/// <returns></returns>
private IMoveableSection getSliceOfArea(double Area, SliceType sliceType)
{
double Atar = 0; //target area
double YOffsetTop = 0;
if (Area > this.A)
{
throw new Exception("Section analysis failed. Area of section sub-part exceeds the total area of cross section.");
}
else
{
if (sliceType == SliceType.Top) // need to return the TOP portion of given area
{
Atar = Area;
}
else // need to return the BOTTOM portion of given area
{
Atar = this.A - Area;
}
YOffsetTop = GetSlicePlaneTopOffset(Atar);
}
double SlicePlaneYCoordinte;
SlicePlaneYCoordinte = this.YMax - YOffsetTop;
IMoveableSection s = getSliceAtCoordinate(SlicePlaneYCoordinte, sliceType);
return(s);
}
public SliceHeader(Stream @is)
{
@is.ReadByte();
CAVLCReader reader = new CAVLCReader(@is);
first_mb_in_slice = reader.readUE("SliceHeader: first_mb_in_slice");
switch (reader.readUE("SliceHeader: slice_type"))
{
case 0:
case 5:
slice_type = SliceType.P;
break;
case 1:
case 6:
slice_type = SliceType.B;
break;
case 2:
case 7:
slice_type = SliceType.I;
break;
case 3:
case 8:
slice_type = SliceType.SP;
break;
case 4:
case 9:
slice_type = SliceType.SI;
break;
}
}
private static ContoursPerSlice GenerateContoursPerSlice(
Volume3D <byte> volume,
bool fillContours,
byte foregroundId,
SliceType sliceType,
bool filterEmptyContours,
Region3D <int> regionOfInterest,
ContourSmoothingType axialSmoothingType)
{
var region = regionOfInterest ?? new Region3D <int>(0, 0, 0, volume.DimX - 1, volume.DimY - 1, volume.DimZ - 1);
int startPoint;
int endPoint;
// Only smooth the output on the axial slices
var smoothingType = axialSmoothingType;
switch (sliceType)
{
case SliceType.Axial:
startPoint = region.MinimumZ;
endPoint = region.MaximumZ;
break;
case SliceType.Coronal:
startPoint = region.MinimumY;
endPoint = region.MaximumY;
smoothingType = ContourSmoothingType.None;
break;
case SliceType.Sagittal:
startPoint = region.MinimumX;
endPoint = region.MaximumX;
smoothingType = ContourSmoothingType.None;
break;
default:
throw new ArgumentOutOfRangeException(nameof(sliceType), sliceType, null);
}
var numberOfSlices = endPoint - startPoint + 1;
var arrayOfContours = new Tuple <int, IReadOnlyList <ContourPolygon> > [numberOfSlices];
for (var i = 0; i < arrayOfContours.Length; i++)
{
var z = startPoint + i;
var volume2D = ExtractSlice.Slice(volume, sliceType, z);
var contours = fillContours ?
ContoursFilled(volume2D, foregroundId, smoothingType):
ContoursWithHoles(volume2D, foregroundId, smoothingType);
arrayOfContours[i] = Tuple.Create(z, contours);
}
return(new ContoursPerSlice(
arrayOfContours
.Where(x => !filterEmptyContours || x.Item2.Count > 0)
.ToDictionary(x => x.Item1, x => x.Item2)));
}
/// <summary>
/// Extracts contours from all slices of the given volume, searching for the given foreground value.
/// Contour extraction will take holes into account.
/// </summary>
/// <param name="volume"></param>
/// <param name="foregroundId">The voxel value that should be used in the contour search as foreground.</param>
/// <param name="axialSmoothingType">The smoothing that should be applied when going from a point polygon to
/// contours. This will only affect axial slice, for other slice types no smoothing will be applied.
/// <param name="sliceType">The type of slice that should be used for contour extraction.</param>
/// <param name="filterEmptyContours">If true, contours with no points are not extracted.</param>
/// <param name="regionOfInterest"></param>
/// <returns></returns>
public static ContoursPerSlice ContoursWithHolesPerSlice(
this Volume3D <byte> volume,
byte foregroundId = ModelConstants.MaskForegroundIntensity,
SliceType sliceType = SliceType.Axial,
bool filterEmptyContours = true,
Region3D <int> regionOfInterest = null,
ContourSmoothingType axialSmoothingType = ContourSmoothingType.Small)
=> ExtractContours.ContoursWithHolesPerSlice(volume, foregroundId, sliceType, filterEmptyContours, regionOfInterest, axialSmoothingType);
/// <summary>
/// Handles texture update events.
/// </summary>
/// <param name="type">type of texture that was updated</param>
/// <param name="index">index of the updated texture</param>
public void TextureUpdated(SliceType type, int index)
{
if (CurrentSliceType == type && _selection[CurrentSliceType] == index)
{
Display.texture = _imageStack.GetTexture2D(CurrentSliceType, _selection[CurrentSliceType]);
ResetClick();
}
}
/// <summary>
/// Handles Segment update events
/// </summary>
/// <param name="tex">actual texture that was updated</param>
/// <param name="type">SliceType of the texture</param>
/// <param name="index">index of the updated texture</param>
public void SegmentTextureUpdated(Texture2D tex, SliceType type, int index)
{
if (CurrentSliceType != type || !_selection.ContainsKey(CurrentSliceType) || _selection[CurrentSliceType] != index)
{
return;
}
SegmentImage.texture = tex;
SegmentImage.color = _segmentTransparency;
}
//public bool CheckTimeStamp(ulong previous) {
// decimal duration = (decimal) TimeStamp - (decimal) previous;
// if (Math.Abs(SliceDuration - duration) > (SliceDuration/100)) // if discrepancy is more than 1%
// return false;
// else {
// return true;
// }
//}
public void Copy(StreamDataBlockInfo copyFrom)
{
this.StreamOffset = copyFrom.StreamOffset;
this.SliceSize = copyFrom.SliceSize;
this.SliceDuration = copyFrom.SliceDuration;
this.TimeStampNew = copyFrom.TimeStampNew;
this.CTS = copyFrom.CTS;
this.index = copyFrom.index;
this.SliceType = copyFrom.SliceType;
}
/// <summary>
/// Extracts contours from all slices of the given volume, searching for the given foreground value.
/// Contour extraction will take holes into account.
/// </summary>
/// <param name="volume"></param>
/// <param name="foregroundId">The voxel value that should be used in the contour search as foreground.</param>
/// <param name="axialSmoothingType">The smoothing that should be applied when going from a point polygon to
/// contours. This will only affect axial slice, for other slice types no smoothing will be applied.
/// <param name="sliceType">The type of slice that should be used for contour extraction.</param>
/// <param name="filterEmptyContours">If true, contours with no points are not extracted.</param>
/// <param name="regionOfInterest"></param>
/// <returns></returns>
public static ContoursPerSlice ContoursFilledPerSlice(
Volume3D <byte> volume,
byte foregroundId = ModelConstants.MaskForegroundIntensity,
SliceType sliceType = SliceType.Axial,
bool filterEmptyContours = true,
Region3D <int> regionOfInterest = null,
ContourSmoothingType axialSmoothingType = ContourSmoothingType.Small)
{
return(GenerateContoursPerSlice(volume, true, foregroundId, sliceType, filterEmptyContours, regionOfInterest, axialSmoothingType));
}
public static SliceType GetSliceType(Slice inSlice)
{
// tryout
byte[] payload = new byte[inSlice.SliceBytes.Length];
inSlice.SliceBytes.CopyTo(payload, 0);
H264Utilities.ToH264Block(payload);
SliceType sliceT = H264Utilities.GetSliceTypeFromH264Payload(payload);
return(sliceT);
}
/// <summary>
/// Calculate number of words to fit complete instruction bytecode.
/// </summary>
/// <returns>Number of words in instruction bytecode.</returns>
public override uint GetWordCount()
{
uint wordCount = 0;
wordCount += IdResultType.GetWordCount();
wordCount += IdResult.GetWordCount();
wordCount += SliceType.GetWordCount();
wordCount += Qp.GetWordCount();
return(wordCount);
}
/// <summary>
/// Extracts a slice of a chosen type (orientation) from the present volume, and returns it as a
/// <see cref="Volume2D"/> instance of correct size. Note that these slices are NOT extracted
/// according to the patient-centric coordinate system, but in the coordinate system of the volume
/// alone.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="volume"></param>
/// <param name="sliceType"></param>
/// <param name="index"></param>
/// <returns></returns>
public static Volume2D <T> Slice <T>(Volume3D <T> volume, SliceType sliceType, int index)
{
var result = AllocateSlice <T, T>(volume, sliceType);
if (result != null)
{
Extract(volume, sliceType, index, result.Array);
}
return(result);
}
public bool readMBSkipFlag(MDecoder mDecoder, SliceType slType, bool leftAvailable, bool topAvailable,
int mbX)
{
int bbase = slType == SliceType.P ? 11 : 24;
bool ret = mDecoder.decodeBin(bbase + (leftAvailable && !skipFlagLeft ? 1 : 0)
+ (topAvailable && !skipFlagsTop[mbX] ? 1 : 0)) == 1;
skipFlagLeft = skipFlagsTop[mbX] = ret;
return(ret);
}
private Slice slice; // TODO only one slice for now
#endregion Fields
#region Constructors
protected Picture(VideoSequence videoSequence, int pictureNumber, int lastIdr)
{
number = pictureNumber;
idrFlag = (pictureNumber == lastIdr);
frameNum = idrFlag ? 0 : pictureNumber - lastIdr;
qp = 28; // TODO QPISlice QP for I Slices must come from Control
picSizeInMbs = videoSequence.FrameSizeInMbs; // frame picture
width = videoSequence.FrameSize.Width;
height = videoSequence.FrameSize.Height;
type = SliceType.Slice; // TODO always set to Intra
InitFrame();
}
/// <summary>
/// Returns the maximum value for the given slice type, starting from 0.
/// </summary>
/// <param name="type">Requested SliceType</param>
/// <returns>Max Value for the SliceType</returns>
public int GetMaxValue(SliceType type)
{
switch (type)
{
case SliceType.Transversal: return(DicomFiles.Length - 1);
case SliceType.Frontal: return(Height - 1);
case SliceType.Sagittal: return(Width - 1);
default: return(0);
}
}
public int GetNumSlices(SliceType sliceType)
{
switch (sliceType)
{
case SliceType.Axial:
return(_sizeZ);
case SliceType.Coronal:
return(_sizeY);
case SliceType.Sagittal:
return(_sizeX);
}
return(0);
}
/// <summary>
/// Extracts a slice of a given type (orientation) from the present volume, and writes it to
/// the provided array in <paramref name="outVolume"/>.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="volume"></param>
/// <param name="sliceType"></param>
/// <param name="sliceIndex"></param>
/// <param name="outVolume"></param>
/// <param name="skip"></param>
private static void Extract <T>(Volume3D <T> volume, SliceType sliceType, int sliceIndex, T[] outVolume, int skip = 1)
{
switch (sliceType)
{
case SliceType.Axial:
if (sliceIndex < volume.DimZ && outVolume.Length == volume.DimXY * skip)
{
Parallel.For(0, volume.DimY, y =>
{
for (var x = 0; x < volume.DimX; x++)
{
outVolume[(x + y * volume.DimX) * skip] = volume[(sliceIndex * volume.DimY + y) * volume.DimX + x];
}
});
}
break;
case SliceType.Coronal:
if (sliceIndex < volume.DimY && outVolume.Length == volume.DimZ * volume.DimX * skip)
{
Parallel.For(0, volume.DimZ, z =>
{
for (var x = 0; x < volume.DimX; x++)
{
outVolume[(x + z * volume.DimX) * skip] = volume[(z * volume.DimY + sliceIndex) * volume.DimX + x];
}
});
}
break;
case SliceType.Sagittal:
if (sliceIndex < volume.DimX && outVolume.Length == volume.DimY * volume.DimZ * skip)
{
Parallel.For(0, volume.DimZ, z =>
{
for (var y = 0; y < volume.DimY; y++)
{
outVolume[(y + z * volume.DimY) * skip] = volume[(z * volume.DimY + y) * volume.DimX + sliceIndex];
}
});
}
break;
}
}
/// <summary>
/// Calculates a section based on slicing criteria
/// </summary>
/// <param name="YCoordinate">Plane Y coordinate in local coordinate system</param>
/// <param name="sliceType">Indicates whether top or bottom slice is returned</param>
/// <returns></returns>
private IMoveableSection getSliceAtCoordinate(double YCoordinate, SliceType sliceType)
{
ArbitraryCompoundShape newShape = new ArbitraryCompoundShape(null, null);
if (sliceType == SliceType.Top)
{
var sortedRectanglesX = RectanglesXAxis.OrderByDescending(r => r.InsertionPoint.Y).ToList();
foreach (var r in sortedRectanglesX)
{
if (r.Ymax > YCoordinate && r.Ymin >= YCoordinate)
{
newShape.rectanglesXAxis.Add(r);
}
else if (r.Ymax >= YCoordinate && r.Ymin <= YCoordinate)
{
double thisRectHeight = r.Ymax - YCoordinate;
newShape.rectanglesXAxis.Add(new CompoundShapePart(r.b, thisRectHeight, new Point2D(0, r.Ymax - thisRectHeight / 2.0)));
}
else
{
//do nothing since this rectangle does not belong here
}
}
}
else
{
var sortedRectanglesX = RectanglesXAxis.OrderBy(r => r.InsertionPoint.Y).ToList();
foreach (var r in sortedRectanglesX)
{
if (r.Ymax <= YCoordinate && r.Ymin < YCoordinate)
{
newShape.rectanglesXAxis.Add(r);
}
else if (r.Ymax > YCoordinate && r.Ymin <= YCoordinate)
{
double thisRectHeight = YCoordinate - r.Ymin;
newShape.rectanglesXAxis.Add(new CompoundShapePart(r.b, thisRectHeight, new Point2D(0, r.Ymin + thisRectHeight / 2.0)));
}
else
{
//do nothing since this rectangle does not belong here
}
}
}
return(newShape);
}
bool IsAudio(SliceType sampType)
{
if (sampType == SliceType.AAC)
{
return(true);
}
if (sampType == SliceType.MP4A)
{
return(true);
}
if (sampType == SliceType.WMA)
{
return(true);
}
return(false);
}
/// <summary>
/// Checks if the arrays containing the slices exist.
/// </summary>
/// <param name="type">Requested SliceType</param>
/// <returns>True if the corresponding array is not null</returns>
public bool HasData(SliceType type)
{
switch (type)
{
case SliceType.Transversal:
return(_transversalTexture2Ds != null);
case SliceType.Frontal:
return(_frontalTexture2Ds != null);
case SliceType.Sagittal:
return(_sagittalTexture2Ds != null);
default:
return(false);
}
}
int AverageIFrameCountPerBlockTimesTwo()
{
SliceType typeOfAnySlice = cache[readCache].SampleStreamLocations[0].SliceType;
if (typeOfAnySlice != SliceType.IFrame && typeOfAnySlice != SliceType.DFrame)
{
return(0);
}
int iFrameCount = 0;
for (int i = 0; i < CacheBufCount; i++)
{
iFrameCount += cache[i].SampleStreamLocations.Count(s => s.SliceType == SliceType.IFrame);
}
return((iFrameCount << 1) / CacheBufCount);
}
public static IPizzaCutting CreateCutting(SliceType type)
{
IPizzaCutting result = null;
switch (type)
{
case SliceType.Base:
result = new BaseCutting();
break;
case SliceType.Square:
result = new SquareCutting();
break;
}
return(result);
}
public static Texture2D Create9Slice(Texture2D sourceTex, Params param)
{
SliceType sliceType = SliceType.Slice9;
if ((param.l <= 0 || param.r <= 0) && (param.t <= 0 || param.b <= 0))
{
Debug.LogWarning("l,t,r,b 设置异常 不能导出九宫格图");
return(sourceTex);
}
if (param.l <= 0 || param.r <= 0)
{
sliceType = SliceType.SliceTB;
}
else if (param.t <= 0 || param.b <= 0)
{
sliceType = SliceType.SliceLR;
}
else
{
sliceType = SliceType.Slice9;
}
Texture2D destTex = new Texture2D(param.destWidth, param.destHeight);
Color[] destPix = new Color[destTex.width * destTex.height];
TextureParam tParam = new TextureParam(sourceTex, destTex, destPix);
int y = 0;
while (y < destTex.height)
{
int x = 0;
while (x < destTex.width)
{
SetPixels(x, y, param, tParam, sliceType);
x++;
}
y++;
}
destTex.SetPixels(destPix);
return(destTex);
}
public Texture2D GetSlice(int sliceNum, SliceType sliceType, bool reversed = false)
{
if (_minWindow != 0 || _windowWidth != 255)
{
return(ConstructSlice(sliceNum, sliceType, reversed));
}
switch (sliceType)
{
case SliceType.Axial:
if (reversed)
{
return(_axialTexturesReversed[sliceNum]);
}
else
{
return(_axialTextures[sliceNum]);
}
case SliceType.Coronal:
if (reversed)
{
return(_coronalTexturesReversed[sliceNum]);
}
else
{
return(_coronalTextures[sliceNum]);
}
case SliceType.Sagittal:
if (reversed)
{
return(_sagittalTexturesReversed[sliceNum]);
}
else
{
return(_sagittalTextures[sliceNum]);
}
}
return(_axialTextures[sliceNum]);
}
public void ExportSlicesToBmps(string folderPath, SliceType sliceType)
{
if (Header.dim == null || Header.dim.Length < 4 || Header.dim[3] == 0)
{
throw new Exception("dim[3] in nifti file header not valid");
}
if (Directory.Exists(folderPath))
{
throw new Exception($"Folder already exists! [{folderPath}]");
}
Directory.CreateDirectory(folderPath);
var sliceCount = Header.dim[(int)sliceType + 1];
var digits = (int)Math.Log10(sliceCount) + 1;
for (var i = 0; i < sliceCount; i++)
{
GetSlice(i, sliceType).Save($@"{folderPath}\{(i + 1).ToString($"D{digits}")}.bmp", ImageFormat.Bmp);
}
}
/// <summary>
/// Writes segmentation data of the slice type into the given texture.
/// </summary>
/// <param name="texture2D">target texture2D</param>
/// <param name="sliceType">type of slice to be displayed</param>
/// <param name="index">index of the slice</param>
public void WriteToTexture(Texture2D texture2D, SliceType sliceType, int index)
{
switch (sliceType)
{
case SliceType.Transversal:
WriteToTransversal(texture2D, index);
break;
case SliceType.Sagittal:
WriteToSagittal(texture2D, index);
break;
case SliceType.Frontal:
WriteToFrontal(texture2D, index);
break;
default:
throw new ArgumentOutOfRangeException(nameof(sliceType), sliceType, "Invalid SliceType");
}
}
/// <summary>
/// Swaps the displayed SliceType for the given SliceType
/// </summary>
/// <param name="type">SliceType to display.</param>
public void Show(SliceType type)
{
CurrentSliceType = type;
_ignoreSliderChanges = true;
SliceSlider.MaximumValue = _imageStack.GetMaxValue(CurrentSliceType);
_ignoreSliderChanges = false;
SliceSlider.CurrentInt = _selection[CurrentSliceType];
Display.texture = _imageStack.GetTexture2D(CurrentSliceType, _selection[CurrentSliceType]);
if (ClickDisplay.texture.width != Display.texture.width ||
ClickDisplay.texture.height != Display.texture.height)
{
ResetClickDisplay(Display.texture.width, Display.texture.height);
}
else
{
ResetClick();
}
}
public SliceHeader(Slice slice, Nalu nalu, SequenceParameterSet sps, PictureParameterSet pps)
{
this.slice = slice;
// BEGIN: parameters from Nalu, Picture Par Set and Sequence Par Set
picParameterSetId = pps.PicParameterSetId;
log2MaxFrameNumMinus4 = sps.Log2MaxFrameNumMinus4;
frameMbsOnlyFlag = sps.FrameMbsOnlyFlag;
picOrderCntType = sps.PicOrderCntType;
log2MaxPicOrderCntLsbMinus4 = sps.Log2MaxPicOrderCntLsbMinus4;
picInitQpMinus26 = pps.PicInitQpMinus26;
nalRefIdc = nalu.NalRefIdc;
nalUnitType = nalu.NalUnitType;
// END: parameters from Nalu, Picture Par Set and Sequence Par Set
sliceType = slice.Picture.TypeOfSlice;
firstMbInSlice = slice.Picture.CurrentMbNr;
noOutputOfPriorPicsFlag = false;
longTermReferenceFlag = false;
sliceQpDelta = (slice.Qp - 26 - picInitQpMinus26);
}
internal EncapsDecoder10(InputStream stream, Encaps encaps, bool sliceValues, ValueFactoryManager f,
ClassResolver cr)
: base(stream, encaps, sliceValues, f, cr)
{
_sliceType = SliceType.NoSlice;
}
bool IsAudio(SliceType sampType)
{
if (sampType == SliceType.AAC)
return true;
if (sampType == SliceType.MP4A)
return true;
if (sampType == SliceType.WMA)
return true;
return false;
}
private void addSide(Texture2D src, Rectangle dstRect, int dx, int dy, int sx, int sy, SliceType st)
{
Rectangle srcRect = new Rectangle();
srcRect.X = sx;
srcRect.Y = sy;
dstRect.X += dx;
dstRect.Y += dy;
switch (st) {
case SliceType.Horizontal:
srcRect.Width = dstRect.Width = Tile.Size;
srcRect.Height = dstRect.Height = Tile.Size / 2;
TextureUtilities.blit(src, srcRect, atlas, dstRect);
break;
case SliceType.Vertical:
srcRect.Width = dstRect.Width = Tile.Size / 2;
srcRect.Height = dstRect.Height = Tile.Size;
TextureUtilities.blit(src, srcRect, atlas, dstRect);
break;
}
}
private void push(SliceType sliceType)
{
if(_current == null)
{
_current = new InstanceData(null);
}
else
{
_current = _current.next == null ? new InstanceData(_current) : _current.next;
}
_current.sliceType = sliceType;
_current.skipFirstSlice = false;
}
internal abstract void startInstance(SliceType type);
/// <summary>
/// Iterates the section until a top or bottom slice (as specified)
/// is of requested area.
/// </summary>
/// <param name="Area"></param>
/// <param name="sliceType"></param>
/// <returns></returns>
private IMoveableSection getSliceOfArea(double Area, SliceType sliceType)
{
double Atar = 0; //target area
double YOffsetTop = 0;
if (Area > this.A)
{
throw new Exception("Section analysis failed. Area of section sub-part exceeds the total area of cross section.");
}
else
{
if (sliceType == SliceType.Top) // need to return the TOP portion of given area
{
Atar = Area;
}
else // need to return the BOTTOM portion of given area
{
Atar = this.A - Area;
}
YOffsetTop = GetSlicePlaneTopOffset(Atar);
}
double SlicePlaneYCoordinte;
SlicePlaneYCoordinte = this.YMax - YOffsetTop;
IMoveableSection s = getSliceAtCoordinate(SlicePlaneYCoordinte, sliceType);
return s;
}
internal override Ice.SlicedData endInstance(bool preserve)
{
//
// Read the Ice::Object slice.
//
if(_sliceType == SliceType.ValueSlice)
{
startSlice();
int sz = _stream.readSize(); // For compatibility with the old AFM.
if(sz != 0)
{
throw new Ice.MarshalException("invalid Object slice");
}
endSlice();
}
_sliceType = SliceType.NoSlice;
return null;
}
internal override void throwException(UserExceptionFactory factory)
{
Debug.Assert(_sliceType == SliceType.NoSlice);
//
// User exception with the 1.0 encoding start with a bool flag
// that indicates whether or not the exception has classes.
//
// This allows reading the pending instances even if some part of
// the exception was sliced.
//
bool usesClasses = _stream.readBool();
_sliceType = SliceType.ExceptionSlice;
_skipFirstSlice = false;
//
// Read the first slice header.
//
startSlice();
string mostDerivedId = _typeId;
while(true)
{
Ice.UserException userEx = null;
//
// Use a factory if one was provided.
//
if(factory != null)
{
try
{
factory(_typeId);
}
catch(Ice.UserException ex)
{
userEx = ex;
}
}
if(userEx == null)
{
userEx = _stream.createUserException(_typeId);
}
//
// We found the exception.
//
if(userEx != null)
{
userEx.read__(_stream);
if(usesClasses)
{
readPendingValues();
}
throw userEx;
// Never reached.
}
//
// Slice off what we don't understand.
//
skipSlice();
try
{
startSlice();
}
catch(Ice.UnmarshalOutOfBoundsException ex)
{
//
// An oversight in the 1.0 encoding means there is no marker to indicate
// the last slice of an exception. As a result, we just try to read the
// next type ID, which raises UnmarshalOutOfBoundsException when the
// input buffer underflows.
//
// Set the reason member to a more helpful message.
//
ex.reason = "unknown exception type `" + mostDerivedId + "'";
throw;
}
}
}
private void readInstance()
{
int index = _stream.readInt();
if(index <= 0)
{
throw new Ice.MarshalException("invalid object id");
}
_sliceType = SliceType.ValueSlice;
_skipFirstSlice = false;
//
// Read the first slice header.
//
startSlice();
string mostDerivedId = _typeId;
Ice.Object v = null;
while(true)
{
//
// For the 1.0 encoding, the type ID for the base Object class
// marks the last slice.
//
if(_typeId.Equals(Ice.ObjectImpl.ice_staticId()))
{
throw new NoValueFactoryException("", mostDerivedId);
}
v = newInstance(_typeId);
//
// We found a factory, we get out of this loop.
//
if(v != null)
{
break;
}
//
// If slicing is disabled, stop unmarshaling.
//
if(!_sliceValues)
{
throw new NoValueFactoryException("no value factory found and slicing is disabled", _typeId);
}
//
// Slice off what we don't understand.
//
skipSlice();
startSlice(); // Read next Slice header for next iteration.
}
//
// Unmarshal the instance and add it to the map of unmarshaled instances.
//
unmarshal(index, v);
}
internal override void startInstance(SliceType sliceType)
{
Debug.Assert(_current.sliceType == sliceType);
_current.skipFirstSlice = true;
}
/// <summary>
/// Calculates a section based on slicing criteria
/// </summary>
/// <param name="YCoordinate">Plane Y coordinate in local coordinate system</param>
/// <param name="sliceType">Indicates whether top or bottom slice is returned</param>
/// <returns></returns>
private IMoveableSection getSliceAtCoordinate(double YCoordinate, SliceType sliceType)
{
ArbitraryCompoundShape newShape = new ArbitraryCompoundShape(null, null);
if (sliceType == SliceType.Top)
{
var sortedRectanglesX = RectanglesXAxis.OrderByDescending(r => r.InsertionPoint.Y).ToList();
foreach (var r in sortedRectanglesX)
{
if (r.Ymax > YCoordinate && r.Ymin >= YCoordinate)
{
newShape.rectanglesXAxis.Add(r);
}
else if (r.Ymax >= YCoordinate && r.Ymin <= YCoordinate)
{
double thisRectHeight = r.Ymax - YCoordinate;
newShape.rectanglesXAxis.Add(new CompoundShapePart(r.b, thisRectHeight, new Point2D(0, r.Ymax - thisRectHeight / 2)));
}
else
{
//do nothing since this rectangle does not belong here
}
}
}
else
{
var sortedRectanglesX = RectanglesXAxis.OrderBy(r => r.InsertionPoint.Y).ToList();
foreach (var r in sortedRectanglesX)
{
if (r.Ymax <= YCoordinate && r.Ymin < YCoordinate)
{
newShape.rectanglesXAxis.Add(r);
}
else if (r.Ymax > YCoordinate && r.Ymin <= YCoordinate)
{
double thisRectHeight = YCoordinate - r.Ymin;
newShape.rectanglesXAxis.Add(new CompoundShapePart(r.b, thisRectHeight, new Point2D(0, r.Ymin + thisRectHeight / 2)));
}
else
{
//do nothing since this rectangle does not belong here
}
}
}
return newShape;
}
//private int sliceNr;
public Slice(Picture picture, SliceType sliceType)
{
this.picture = picture;
macroblocks = new List<Macroblock>();
this.sliceType = sliceType;
}
public H264Mb(CommonMbH264 eltMb)
: base(eltMb)
{
m_Mode = eltMb.getMode();
m_SliceType = eltMb.getSliceType();
m_MbType = eltMb.getMbType();
m_QP = eltMb.getQP();
m_QPC = eltMb.getQPC();
m_CBP = eltMb.getCBP();
m_IsIntra16x16 = eltMb.isIntra16x16();
m_IsInter8x8 = eltMb.isInter8x8();
m_IsIntra = eltMb.isIntra();
m_NumMbPart = 1;
m_MbPartSize = new Size(16, 16);
if (m_Mode == MbMode.INTRA_4X4)
{
m_Intra4x4PredModes = new Intra4x4PredMode[16];
eltMb.getIntra4x4PredMode(m_Intra4x4PredModes);
}
else if (m_IsIntra16x16)
{
m_I16x16Type = (m_SliceType == SliceType.P_SLICE) ? (I16x16Type)(m_MbType - 5) : (I16x16Type)m_MbType;
}
else if (m_SliceType == SliceType.P_SLICE)
{
if (m_MbType < 5 || m_Mode == MbMode.MODE_SKIP)
{
if (m_Mode == MbMode.MODE_SKIP)
{
m_NumMbPart = 1;
m_MbPartSize = new Size(16, 16);
}
else
{
m_PType = (PType)m_MbType;
if (m_MbType < PartNumP.Length)
{
m_NumMbPart = PartNumP[m_MbType];
}
if (m_MbType < PartSizeP.Length)
{
m_MbPartSize = new Size((int)PartSizeP[m_MbType][0], (int)PartSizeP[m_MbType][1]);
}
}
}
else if (m_MbType == 5)
{
// I_4x4
Debug.Assert(false);
m_IsIntra = true;
}
else
{
// I_16x16
m_I16x16Type = (I16x16Type)(m_MbType - 5);
m_IsIntra = true;
m_IsIntra16x16 = true;
}
}
else if (m_SliceType == SliceType.B_SLICE)
{
m_BType = (BType)m_MbType;
if (m_MbType < PartNumB.Length)
{
m_NumMbPart = PartNumB[m_MbType];
}
if (m_MbType < PartSizeP.Length)
{
m_MbPartSize = new Size((int)PartSizeB[m_MbType][0], (int)PartSizeB[m_MbType][1]);
}
}
if (m_IsInter8x8)
{
m_BlkModes = new BlkMode[4];
eltMb.getBlkModes(m_BlkModes);
}
if (m_IsIntra)
{
m_IntraChromaPredMode = eltMb.getIntraChromaPredMode();
}
else
{
m_ref_idx_L0 = new Int32[4];
m_POC0 = new Int32[4];
m_mvd_l0 = eltMb.getMvdL0();
m_mvL0 = eltMb.getMvL0();
eltMb.getRefIdxL0(m_ref_idx_L0);
eltMb.getPOC0(m_POC0);
if (SliceType == SliceType.B_SLICE)
{
m_ref_idx_L1 = new Int32[4];
m_POC1 = new Int32[4];
m_mvd_l1 = eltMb.getMvdL1();
m_mvL1 = eltMb.getMvL1();
eltMb.getRefIdxL1(m_ref_idx_L1);
eltMb.getPOC1(m_POC1);
}
}
/*** SVC ***/
m_IsInCropWindow = eltMb.isInCropWindow();
m_IsResidualPredictionFlag = eltMb.isResidualPredictionFlag();
m_IsBLSkippedFlag = eltMb.isBLSkippedFlag();
}
/// <summary>
/// Convert slice to full unit name.
/// </summary>
/// <param name="slice">
/// Slice string should be the same format with the ones in array:
/// _nucleusTruncateRules, _unsetTruncateRules, _codaTruncateRules.
/// For example : a+t1+b
/// The slice contains phone and tone.
/// </param>
/// <param name="type">Slice Type.</param>
/// <returns>Full unit name.</returns>
public static string BuildFullUnitName(string slice, SliceType type)
{
if (string.IsNullOrEmpty(slice))
{
throw new ArgumentNullException("slice");
}
string fullName = slice.Replace(" ", TtsUnit.PhoneDelimiter);
switch (type)
{
case SliceType.Onset:
fullName = TtsUnit.OnsetPrefix + fullName;
break;
case SliceType.Nucleus:
fullName = TtsUnit.NucleusPrefix + fullName;
break;
case SliceType.Coda:
fullName = TtsUnit.CodaPrefix + fullName;
break;
case SliceType.Special:
fullName = TtsUnit.NucleusPrefix + "_" + fullName + "_";
break;
default:
Debug.Assert(false);
string message = string.Format(CultureInfo.InvariantCulture,
"[{0}]: Invalid slice type. Only Onset, Nuclues, Coda and Speical are support",
type);
throw new NotSupportedException(message);
}
return fullName;
}
