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); } } }