public static NDArray array(Array array, Type dtype = null, int ndmin = 1, bool copy = true, char order = 'C')
{
var arrType = array.ResolveElementType();
//handle dim expansion and extract shape
Shape shape;
var dims = array.ResolveRank();
var missing = dims - ndmin;
if (missing < 0)
{
shape = Arrays.Concat(Enumerable.Repeat(1, Math.Abs(missing)).ToArray(), Shape.ExtractShape(array));
}
else
{
shape = Shape.ExtractShape(array);
}
//flatten
if (shape.NDim > 1)
{
array = Arrays.Flatten(array);
copy = false;
}
if (dtype != null && dtype != arrType)
{
array = ArrayConvert.To(array, dtype);
copy = false;
}
return(new NDArray(copy ? (Array)array.Clone() : array, shape, order));
}
public void WriteRow(FixedWidthRow row)
{
if (this._fs.Position == 0 && this._wCols)
{
string colHeader = "";
foreach (FixedWidthColumn col in this._cols)
{
colHeader += ParseField(col, col.ColumnName);
}
byte[] hdr = ArrayConvert.ToBytes(colHeader + "\r\n");
this._fs.Write(hdr, 0, hdr.Length);
}
string wVal = "";
for (int i = 0; i < row.FieldValues.Count; i++)
{
if (i < this._cols.Count)
{
wVal += ParseField(this._cols[i], row[i]);
}
else
{
wVal += row[i];
}
}
byte[] b = ArrayConvert.ToBytes(wVal + "\r\n");
this._fs.Write(b, 0, b.Length);
}
/// <summary>
/// 指定されたバッファをストリームに書き込みます。
/// </summary>
/// <param name="buffer">書き込まれるデータが格納された short 型配列。</param>
/// <param name="offset">書き込みを開始する配列のオフセット。</param>
/// <param name="count">書き込まれるデータ数。</param>
unsafe public override void Write(short[] buffer, int offset, int count)
{
if (this.Disposed)
{
throw new ObjectDisposedException("BaseStream");
}
if (this.BitPerSample == 16)
{
count *= 2;
}
byte[] buf = new byte[count];
if (this.BitPerSample == 8)
{
ArrayConvert.RegulateAsInt8(buffer, offset, count, buf);
}
else
{
ArrayConvert.ToByte(buffer, offset, count, buf, BitConverter.IsLittleEndian);
}
this.BaseStream.Write(buf, offset, count);
this.WrittenBytes += count;
}
public NDArray Cast(NDArray nd, NPTypeCode dtype, bool copy)
{
if (dtype == NPTypeCode.Empty)
{
throw new ArgumentNullException(nameof(dtype));
}
NDArray clone()
{
var copied = new NDArray(nd.dtype, nd.TensorEngine);
copied.Storage.Allocate(ArrayConvert.To(nd.Array, dtype), nd.shape);
return(copied);
}
if (nd.GetTypeCode == dtype)
{
//casting not needed
return(copy ? clone() : nd);
}
else
{
//casting needed
if (copy)
{
return(clone());
}
//just re-set the data, conversion is handled inside.
nd.Storage.ReplaceData(nd.Storage.GetData(), dtype);
return(nd);
}
}
void Canvas_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.PageUp)
{
ImageScale += ScaleIncrement;
}
if (e.KeyCode == Keys.PageDown)
{
ImageScale -= ScaleIncrement;
}
if (e.Control && e.KeyCode == Keys.Z)
{
commandExecutor.Undo();
}
if (e.Control && e.KeyCode == Keys.Y)
{
commandExecutor.Redo();
}
if (e.Control && e.KeyCode == Keys.V)
{
var roiText = (string)Clipboard.GetData(DataFormats.Text);
try
{
var mousePosition = PointToClient(MousePosition);
var offset = NormalizedLocation(mousePosition.X, mousePosition.Y);
var roiData = (float[])ArrayConvert.ToArray(roiText, 1, typeof(float));
var center = new Point2f(offset.X, offset.Y);
var size = new Size2f(roiData[0], roiData[1]);
var roi = new RotatedRect(center, size, 0);
var selection = selectedRoi;
commandExecutor.Execute(
() => AddRegion(roi),
() => { regions.Remove(roi); SelectedRegion = selection; });
}
catch (ArgumentException) { }
catch (InvalidCastException) { }
catch (FormatException) { }
}
if (selectedRoi.HasValue)
{
if (e.Control && e.KeyCode == Keys.C)
{
var roi = regions[selectedRoi.Value];
var roiData = new[] { roi.Size.Width, roi.Size.Height };
Clipboard.SetData(DataFormats.Text, ArrayConvert.ToString(roiData));
}
if (e.KeyCode == Keys.Delete)
{
var selection = selectedRoi.Value;
var region = regions[selection];
commandExecutor.Execute(
() => { regions.RemoveAt(selection); SelectedRegion = null; },
() => { regions.Insert(selection, region); SelectedRegion = selection; });
}
}
}
public static byte[] GetBytesFrom(object obj, int size)
{
ArrayConvert ar = new ArrayConvert();
ar.obj = obj;
ar.length.val = size;
return(ar.bytes);
}
public static byte[] GetBytes(float[] floats)
{
ArrayConvert ar = new ArrayConvert();
ar.floats = floats;
ar.length.val = floats.Length * 4;
return(ar.bytes);
}
public static float[] GetFloats(byte[] bytes)
{
ArrayConvert ar = new ArrayConvert();
ar.bytes = bytes;
ar.length.val = bytes.Length / 4;
return(ar.floats);
}
public void CastToDoubleTest()
{
var input = new float[] { 3.0f, -2.5f, 1.76f, 2.97e-10f };
var output = new double[4];
var expect = new double[] { 3.0f, -2.5f, 1.76f, 2.97e-10f };
ArrayConvert.CastToDouble(input, output);
CollectionAssert.AreEqual(expect, output);
}
public void Convert_Json_With_JsonHelper()
{
string str = "[[18,2]]";
var result = ArrayConvert.GenerateArray4(str);
Assert.NotNull(result);
Assert.True(result.Count > 0);
}
public void Convert_Json_With_Simple_Array_To_Array3()
{
string str = "[[18,2]]";
var result = ArrayConvert.GenerateArray3(str);
Assert.NotNull(result);
Assert.True(result.Count > 0);
}
/// <summary>
/// Converts the given object to the type of this converter, using the specified
/// context and culture information.
/// </summary>
/// <param name="context">
/// An <see cref="ITypeDescriptorContext"/> that provides a format context.
/// </param>
/// <param name="culture">
/// The <see cref="CultureInfo"/> to use as the current culture.
/// </param>
/// <param name="value">The <see cref="Object"/> to convert.</param>
/// <returns>An <see cref="Object"/> that represents the converted value.</returns>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
var valueString = value as string;
if (valueString != null)
{
var array = (float[, ])ArrayConvert.ToArray(valueString, 2, typeof(float), culture);
return(Mat.FromArray(array));
}
return(base.ConvertFrom(context, culture, value));
}
public static byte[] GetTop4BytesFrom(object obj)
{
ArrayConvert ar = new ArrayConvert();
ar.obj = obj;
return(new byte[]
{
ar.top4bytes.b0,
ar.top4bytes.b1,
ar.top4bytes.b2,
ar.top4bytes.b3
});
}
private void CalcBtn_Click(object sender, EventArgs e)
{
try
{
int[] Arr = ArrayConvert.StrToArray <int>(ArrInput.Text);
ArrayTools At = new ArrayTools(Arr);
CountOut.Text = At.GetCountSumEl().ToString();
}
catch (Exception)
{
MessageBox.Show("ошибка ввода", "ошибка");
}
}
protected override string GetDisplayText(object value)
{
var group = (GroupedRegions)value;
var name = string.IsNullOrEmpty(group.Name) ? "Group" : group.Name;
var regions = group.Regions;
if (regions == null || regions.Length == 0)
{
return(name);
}
else
{
return(string.Format("{0} ({1})", name, ArrayConvert.ToString(group.Regions)));
}
}
/// <summary>
/// Converts the given value object to the specified type, using the specified
/// context and culture information.
/// </summary>
/// <param name="context">
/// An <see cref="ITypeDescriptorContext"/> that provides a format context.
/// </param>
/// <param name="culture">
/// A <see cref="CultureInfo"/>. If <b>null</b> is passed, the current culture
/// is assumed.
/// </param>
/// <param name="value">The <see cref="Object"/> to convert.</param>
/// <param name="destinationType">The <see cref="Type"/> to convert the value parameter to.</param>
/// <returns>An <see cref="Object"/> that represents the converted value.</returns>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (value != null && destinationType == typeof(string))
{
var mat = (Mat)value;
var array = new float[mat.Rows, mat.Cols];
using (var arrayHeader = Mat.CreateMatHeader(array))
{
CV.Convert(mat, arrayHeader);
}
return(ArrayConvert.ToString(array, culture));
}
return(base.ConvertTo(context, culture, value, destinationType));
}
private int ParseSection2(int currentOffset)
{
while (EndOfSectionCheck(currentOffset) == false)
{
int _pos = tsd_File.Events.Count();
int addedOffset = 0;
tsd_File.Events.Add(new TSD_Event());
tsd_File.Events[_pos].Index = BitConverter.ToInt32(rawBytes, currentOffset + 0).ToString();
tsd_File.Events[_pos].I_04 = BitConverter.ToInt32(rawBytes, currentOffset + 4);
addedOffset += 12;
int stringSize = BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4);
tsd_File.Events[_pos].Str1 = StringEx.GetString(rawBytes, currentOffset + addedOffset, false, StringEx.EncodingType.UTF8, BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4), false);
addedOffset += stringSize + 4;
stringSize = BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4);
tsd_File.Events[_pos].Str2 = StringEx.GetString(rawBytes, currentOffset + addedOffset, false, StringEx.EncodingType.UTF8, BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4), false);
addedOffset += stringSize + 4;
stringSize = BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4);
tsd_File.Events[_pos].Str3 = StringEx.GetString(rawBytes, currentOffset + addedOffset, false, StringEx.EncodingType.UTF8, BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4), false);
addedOffset += stringSize + 4;
stringSize = BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4);
tsd_File.Events[_pos].Str4 = StringEx.GetString(rawBytes, currentOffset + addedOffset, false, StringEx.EncodingType.UTF8, BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4), false);
addedOffset += stringSize + 4;
stringSize = BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4);
string args = StringEx.GetString(rawBytes, currentOffset + addedOffset, false, StringEx.EncodingType.UTF8, BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4), false);
tsd_File.Events[_pos].Arguments = EventArguments.Read(args);
addedOffset += stringSize + 4;
//Read TNL ID array
int count = BitConverter.ToInt32(rawBytes, currentOffset + addedOffset - 4);
List <int> tnlIds = BitConverter_Ex.ToInt32Array(rawBytes, currentOffset + addedOffset, count).ToList();
addedOffset += (4 * count);
tsd_File.Events[_pos].TNL_IDs = ArrayConvert.ConvertToStringList(tnlIds);
currentOffset += addedOffset;
}
return(currentOffset);
}
private void ChangeArrBtn_Click(object sender, EventArgs e)
{
try
{
int[] Arr = ArrayConvert.StrToArray <int>(ArrInput.Text);
int K = int.Parse(KInput.Text);
ArrayTools At = new ArrayTools(Arr);
int[] NewArr = At.GetNewArray(ArrayTools.param.less, K);
LessArrOut.Text = ArrayConvert.ArrayToStr <int>(NewArr);
NewArr = At.GetNewArray(ArrayTools.param.equal, K);
EqualArrOut.Text = ArrayConvert.ArrayToStr <int>(NewArr);
NewArr = At.GetNewArray(ArrayTools.param.more, K);
MoreArrOut.Text = ArrayConvert.ArrayToStr <int>(NewArr);
}
catch (Exception)
{
MessageBox.Show("ошибка ввода", "ошибка");
}
}
/// <summary>
/// </summary>
/// <param name="arrayBuffer">
/// </param>
/// <returns>
/// </returns>
public static DDSInfo GetDDSInfo(byte[] arrayBuffer)
{
var header = ArrayConvert.AsInt(arrayBuffer, 0, headerLengthInt);
var mipmapCount = 1;
if ((header[off_flags] & DDSD_MIPMAPCOUNT) > 0)
{
mipmapCount = Math.Max(1, header[off_mipmapCount]);
}
return(new DDSInfoDts
{
width = header[off_width],
height = header[off_height],
mipmapCount = mipmapCount,
isFourCC = (header[off_pfFlags] & DDPF_FOURCC) == DDPF_FOURCC,
isRGB = (header[off_pfFlags] & DDPF_RGB) == DDPF_RGB,
isLuminance = (header[off_pfFlags] & DDPF_LUMINANCE) == DDPF_LUMINANCE,
isCube = (header[off_caps2] & DDSCAPS2_CUBEMAP) == DDSCAPS2_CUBEMAP
});
}
void Canvas_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.PageUp)
{
ImageScale += ScaleIncrement;
}
if (e.KeyCode == Keys.PageDown)
{
ImageScale -= ScaleIncrement;
}
if (e.Control && e.KeyCode == Keys.Z)
{
commandExecutor.Undo();
}
if (e.Control && e.KeyCode == Keys.Y)
{
commandExecutor.Redo();
}
if (e.Control && e.KeyCode == Keys.V)
{
var roiText = (string)Clipboard.GetData(DataFormats.Text);
try
{
var mousePosition = PointToClient(MousePosition);
var offset = NormalizedLocation(mousePosition.X, mousePosition.Y);
var roiData = (int[])ArrayConvert.ToArray(roiText, 1, typeof(int));
var roi = new Point[roiData.Length / 2];
for (int i = 0, k = 0; i < roi.Length && k < roiData.Length; i++, k += 2)
{
roi[i].X = roiData[k + 0] - roiData[0] + offset.X;
roi[i].Y = roiData[k + 1] - roiData[1] + offset.Y;
}
var selection = selectedRoi;
commandExecutor.Execute(
() => AddRegion(roi),
() => { regions.Remove(roi); SelectedRegion = selection; });
}
catch (ArgumentException) { }
catch (InvalidCastException) { }
catch (FormatException) { }
}
if (selectedRoi.HasValue)
{
if (e.Control && e.KeyCode == Keys.C)
{
var roi = regions[selectedRoi.Value];
var roiData = new int[roi.Length * 2];
for (int i = 0, k = 0; i < roi.Length && k < roiData.Length; i++, k += 2)
{
roiData[k + 0] = roi[i].X;
roiData[k + 1] = roi[i].Y;
}
Clipboard.SetData(DataFormats.Text, ArrayConvert.ToString(roiData));
}
if (e.KeyCode == Keys.Delete)
{
var selection = selectedRoi.Value;
var region = regions[selection];
commandExecutor.Execute(
() => { regions.RemoveAt(selection); SelectedRegion = null; },
() => { regions.Insert(selection, region); SelectedRegion = selection; });
}
}
}
/// <summary>
/// </summary>
/// <param name="gl">
/// </param>
/// <param name="data">
/// </param>
public static void UploadContent(WebGLRenderingContext gl, byte[] data)
{
if (data.Length < 19)
{
Tools.Error("Unable to load TGA file - Not enough data to contain header");
return;
}
var offset = 18;
var header = GetTGAHeader(data);
if (header.id_length + offset > data.Length)
{
Tools.Error("Unable to load TGA file - Not enough data");
return;
}
offset += header.id_length;
var use_rle = false;
var use_pal = false;
var use_rgb = false;
var use_grey = false;
switch (header.image_type)
{
case _TYPE_RLE_INDEXED:
use_rle = true;
use_pal = true;
break;
case _TYPE_INDEXED:
use_pal = true;
break;
case _TYPE_RLE_RGB:
use_rle = true;
use_rgb = true;
break;
case _TYPE_RGB:
use_rgb = true;
break;
case _TYPE_RLE_GREY:
use_rle = true;
use_grey = true;
break;
case _TYPE_GREY:
use_grey = true;
break;
}
byte[] pixel_data;
var numAlphaBits = header.flags & 0xf;
var pixel_size = header.pixel_size << 3;
var pixel_total = header.width * header.height * pixel_size;
byte[] palettes = null;
if (use_pal)
{
palettes = ArrayConvert.AsByte(data, offset, header.colormap_length * (header.colormap_size << 3));
}
if (use_rle)
{
pixel_data = new byte[pixel_total];
byte c;
int count;
int i;
var localOffset = 0;
var pixels = new byte[pixel_size];
while (offset < pixel_total)
{
c = data[offset++];
count = (c & 0x7f) + 1;
if ((c & 0x80) > 0)
{
for (i = 0; i < pixel_size; ++i)
{
pixels[i] = data[offset++];
}
for (i = 0; i < count; ++i)
{
pixel_data = ArrayConvert.AsByte(pixels, localOffset, i * pixel_size);
}
localOffset += pixel_size * count;
}
else
{
count *= pixel_size;
for (i = 0; i < count; ++i)
{
pixel_data[localOffset + i] = data[offset++];
}
localOffset += count;
}
}
}
else
{
pixel_data = ArrayConvert.AsByte(data, offset, (use_pal) ? header.width * header.height : pixel_total);
}
int x_start;
int y_start;
int x_step;
int y_step;
int y_end;
int x_end;
switch ((header.flags & _ORIGIN_MASK) << _ORIGIN_SHIFT)
{
default:
case _ORIGIN_UL:
x_start = 0;
x_step = 1;
x_end = header.width;
y_start = 0;
y_step = 1;
y_end = header.height;
break;
case _ORIGIN_BL:
x_start = 0;
x_step = 1;
x_end = header.width;
y_start = header.height - 1;
y_step = -1;
y_end = -1;
break;
case _ORIGIN_UR:
x_start = header.width - 1;
x_step = -1;
x_end = -1;
y_start = 0;
y_step = 1;
y_end = header.height;
break;
case _ORIGIN_BR:
x_start = header.width - 1;
x_step = -1;
x_end = -1;
y_start = header.height - 1;
y_step = -1;
y_end = -1;
break;
}
byte[] imageData = null;
if (use_grey)
{
switch (header.pixel_size)
{
case 8:
imageData = _getImageDataGrey8bits(header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end);
break;
case 16:
imageData = _getImageDataGrey16bits(header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end);
break;
}
}
else
{
switch (header.pixel_size)
{
case 8:
imageData = _getImageData8bits(header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end);
break;
case 16:
imageData = _getImageData16bits(header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end);
break;
case 24:
imageData = _getImageData24bits(header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end);
break;
case 32:
imageData = _getImageData32bits(header, palettes, pixel_data, y_start, y_step, y_end, x_start, x_step, x_end);
break;
}
}
gl.texImage2D(Gl.TEXTURE_2D, 0, Gl.RGBA, header.width, header.height, 0, Gl.RGBA, Gl.UNSIGNED_BYTE, imageData);
}
private void WriteFile()
{
//Section 1
bytes.Add(1);
for (int i = 0; i < tsd_File.Triggers.Count(); i++)
{
bytes.AddRange(BitConverter.GetBytes(int.Parse(tsd_File.Triggers[i].Index)));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Triggers[i].I_04));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Triggers[i].I_08));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Triggers[i].I_12));
bytes.AddRange(BitConverter.GetBytes(int.Parse(tsd_File.Triggers[i].I_16)));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Triggers[i].I_20));
bytes.AddRange(BitConverter.GetBytes(int.Parse(tsd_File.Triggers[i].I_24)));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Triggers[i].I_28));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Triggers[i].Condition)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Triggers[i].Condition));
}
//Section 2
bytes.AddRange(BitConverter.GetBytes(magicNumber));
bytes.Add(2);
for (int i = 0; i < tsd_File.Events.Count(); i++)
{
bytes.AddRange(BitConverter.GetBytes(int.Parse(tsd_File.Events[i].Index)));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Events[i].I_04));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Events[i].Str1)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Events[i].Str1));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Events[i].Str2)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Events[i].Str2));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Events[i].Str3)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Events[i].Str3));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Events[i].Str4)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Events[i].Str4));
string args = tsd_File.Events[i].Arguments.Write();
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(args)));
bytes.AddRange(Encoding.UTF8.GetBytes(args));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Events[i].TNL_IDs.Count()));
List <int> tnlIds = ArrayConvert.ConvertToInt32List(tsd_File.Events[i].TNL_IDs);
bytes.AddRange(BitConverter_Ex.GetBytes(tnlIds.ToArray()));
}
//Section 3
bytes.AddRange(BitConverter.GetBytes(magicNumber));
bytes.Add(3);
for (int i = 0; i < tsd_File.Globals.Count(); i++)
{
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Globals[i].Index)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Globals[i].Index));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Globals[i].Type));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Globals[i].Str)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Globals[i].Str));
}
//Section 4
bytes.AddRange(BitConverter.GetBytes(magicNumber));
bytes.Add(4);
for (int i = 0; i < tsd_File.Constants.Count(); i++)
{
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Constants[i].Index)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Constants[i].Index));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Constants[i].Type));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Constants[i].Str)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Constants[i].Str));
}
//Section 5
bytes.AddRange(BitConverter.GetBytes(magicNumber));
bytes.Add(5);
for (int i = 0; i < tsd_File.Zones.Count(); i++)
{
bytes.AddRange(BitConverter.GetBytes(int.Parse(tsd_File.Zones[i].Index)));
bytes.AddRange(BitConverter.GetBytes(tsd_File.Zones[i].I_04));
bytes.AddRange(BitConverter.GetBytes(Encoding.UTF8.GetByteCount(tsd_File.Zones[i].Str)));
bytes.AddRange(Encoding.UTF8.GetBytes(tsd_File.Zones[i].Str));
}
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
int i, j, k;
bool IsPointData = false;
GH_Structure <IGH_Goo> data = new GH_Structure <IGH_Goo>();
GH_Structure <IGH_GeometricGoo> geo = new GH_Structure <IGH_GeometricGoo>();
List <int> numCluster = new List <int>();
if (!DA.GetDataTree(0, out data))
{
return;
}
if (!DA.GetDataTree(1, out geo))
{
return;
}
if (!DA.GetDataList(2, numCluster))
{
return;
}
data.Simplify(GH_SimplificationMode.CollapseAllOverlaps);
DataTree <IGH_Goo> outputData = new DataTree <IGH_Goo>();
DataTree <IGH_GeometricGoo> outputGeo = new DataTree <IGH_GeometricGoo>();
DataTree <Point3d> outputCentroids = new DataTree <Point3d>();
for (i = 0; i < data.Branches.Count; i++)
{
double[] x = new double[data.Branches[i].Count];
double[] y = new double[data.Branches[i].Count];
double[] z = new double[data.Branches[i].Count];
for (j = 0; j < data.Branches[i].Count; j++)
{
if (data.Branches[i][j] is GH_Point)
{
IsPointData = true;
GH_Point target = new GH_Point();
if (GH_Convert.ToGHPoint(data.Branches[i][j], GH_Conversion.Both, ref target))
{
x[j] = target.Value.X;
y[j] = target.Value.Y;
z[j] = target.Value.Z;
}
}
else
{
break;
}
}
if (IsPointData)
{
List <double[]> datalist = new List <double[]>
{
x,
y,
z
};
double[][] _data = ArrayConvert.To2DArray(datalist);
KMeans m = new KMeans(numCluster[i]);
KMeansClusterCollection cluster = m.Learn(_data);
int[] labels = cluster.Decide(_data);
double[][] centroids = m.Centroids;
for (j = 0; j < data.Branches[i].Count; j++)
{
GH_Path path = new GH_Path(i, labels[j]);
outputData.Add(data.Branches[i][j], path);
outputGeo.Add(geo.Branches[i][j], path);
}
for (k = 0; k < centroids.Length; k++)
{
outputCentroids.Add(new Point3d(centroids.ElementAt(k).ElementAt(0), centroids.ElementAt(k).ElementAt(1), centroids.ElementAt(k).ElementAt(2)), new GH_Path(k));
}
}
else
{
break;
}
}
if (!IsPointData)
{
GH_Path oldPath = new GH_Path();
GH_Path newPath = new GH_Path();
int DataGroupCount = 0;
for (i = 0; i < data.PathCount; i++)
{
if (data.Paths[i].Indices.Length == 1)
{
DataGroupCount = 1;
break;
}
else
{
int[] pp = new int[data.Paths[i].Indices.Length - 1];
for (j = 0; j < data.Paths[i].Indices.Length - 1; j++)
{
pp[j] = data.Paths[i].Indices[j];
}
newPath.Indices = pp;
if (newPath != oldPath)
{
DataGroupCount++;
oldPath = newPath;
}
newPath = new GH_Path();
}
}
for (i = 0; i < DataGroupCount; i++)
{
List <double[]> datalist = new List <double[]>();
for (j = 0; j < data.Branches.Count / DataGroupCount; j++)
{
double[] values = new double[data.Branches[DataGroupCount * i + j].Count];
for (k = 0; k < data.Branches[DataGroupCount * i + j].Count; k++)
{
if (data.Branches[DataGroupCount * i + j][k] is GH_Number)
{
if (GH_Convert.ToDouble(data.Branches[DataGroupCount * i + j][k], out double value, GH_Conversion.Both))
{
values[k] = value;
}
}
else
{
break;
}
}
datalist.Add(values);
}
double[][] _data = ArrayConvert.ToDoubleArray(datalist);
KMeans m = new KMeans(numCluster[0]);
KMeansClusterCollection cluster = m.Learn(_data);
int[] labels = cluster.Decide(_data);
for (j = 0; j < labels.Length; j++)
{
List <IGH_Goo> numbers = new List <IGH_Goo>();
List <IGH_GeometricGoo> geos = new List <IGH_GeometricGoo>();
for (k = 0; k < data.Branches[DataGroupCount * i + j].Count; k++)
{
numbers.Add(data.Branches[DataGroupCount * i + j][k]);
geos.Add(geo.Branches[DataGroupCount * i + j][k]);
}
GH_Path path = new GH_Path(i, j, labels[j]);
outputData.AddRange(numbers, path);
outputGeo.AddRange(geos, path);
}
}
}
DA.SetDataTree(0, outputData);
DA.SetDataTree(1, outputGeo);
DA.SetDataTree(2, outputCentroids);
}
/// <summary>
/// </summary>
/// <param name="gl">
/// </param>
/// <param name="ext">
/// </param>
/// <param name="arrayBuffer">
/// </param>
/// <param name="info">
/// </param>
/// <param name="loadMipmaps">
/// </param>
/// <param name="faces">
/// </param>
public static void UploadDDSLevels(
WebGLRenderingContext gl, WEBGL_compressed_texture_s3tc ext, byte[] arrayBuffer, DDSInfo info, bool loadMipmaps, int faces)
{
var header = ArrayConvert.AsInt(arrayBuffer, 0, headerLengthInt);
int fourCC;
var blockBytes = 0;
var internalFormat = 0;
int width;
int height;
int dataLength;
int dataOffset;
byte[] byteArray;
int mipmapCount;
int i;
if (header[off_magic] != DDS_MAGIC)
{
Tools.Error("Invalid magic number in DDS header");
return;
}
if (!info.isFourCC && !info.isRGB && !info.isLuminance)
{
Tools.Error("Unsupported format, must contain a FourCC, RGB or LUMINANCE code");
return;
}
if (info.isFourCC)
{
fourCC = header[off_pfFourCC];
switch (fourCC)
{
case FOURCC_DXT1:
blockBytes = 8;
internalFormat = ext.COMPRESSED_RGBA_S3TC_DXT1_EXT;
break;
case FOURCC_DXT3:
blockBytes = 16;
internalFormat = ext.COMPRESSED_RGBA_S3TC_DXT3_EXT;
break;
case FOURCC_DXT5:
blockBytes = 16;
internalFormat = ext.COMPRESSED_RGBA_S3TC_DXT5_EXT;
break;
default:
Tools.Error(string.Format("Unsupported FourCC code: {0}", fourCC));
return;
}
}
mipmapCount = 1;
if ((header[off_flags] & DDSD_MIPMAPCOUNT) > 0 && loadMipmaps)
{
mipmapCount = Math.Max(1, header[off_mipmapCount]);
}
var bpp = header[off_RGBbpp];
for (var face = 0; face < faces; face++)
{
var sampler = (faces == 1) ? Gl.TEXTURE_2D : (Gl.TEXTURE_CUBE_MAP_POSITIVE_X + face);
width = header[off_width];
height = header[off_height];
dataOffset = header[off_size] + 4;
for (i = 0; i < mipmapCount; ++i)
{
if (info.isRGB)
{
if (bpp == 24)
{
dataLength = width * height * 3;
byteArray = GetRGBArrayBuffer(width, height, dataOffset, dataLength, arrayBuffer);
gl.texImage2D(sampler, i, Gl.RGB, width, height, 0, Gl.RGB, Gl.UNSIGNED_BYTE, byteArray);
}
else
{
dataLength = width * height * 4;
byteArray = GetRGBAArrayBuffer(width, height, dataOffset, dataLength, arrayBuffer);
gl.texImage2D(sampler, i, Gl.RGBA, width, height, 0, Gl.RGBA, Gl.UNSIGNED_BYTE, byteArray);
}
}
else if (info.isLuminance)
{
var unpackAlignment = (int)gl.getParameter(Gl.UNPACK_ALIGNMENT);
var unpaddedRowSize = width;
var paddedRowSize = (int)Math.Floor((double)(width + unpackAlignment - 1) / unpackAlignment) * unpackAlignment;
dataLength = paddedRowSize * (height - 1) + unpaddedRowSize;
byteArray = GetLuminanceArrayBuffer(width, height, dataOffset, dataLength, arrayBuffer);
gl.texImage2D(sampler, i, Gl.LUMINANCE, width, height, 0, Gl.LUMINANCE, Gl.UNSIGNED_BYTE, byteArray);
}
else
{
dataLength = Math.Max(4, width) / 4 * Math.Max(4, height) / 4 * blockBytes;
byteArray = ArrayConvert.AsByte(arrayBuffer, dataOffset, dataLength);
gl.compressedTexImage2D(sampler, i, internalFormat, width, height, 0, byteArray);
}
dataOffset += dataLength;
width /= 2;
height /= 2;
width = Math.Max(1, width);
height = Math.Max(1, height);
}
}
}
