//Ecris dans un fichier depuis un WAV
public static void WriteFile(string path, DataHeader Header, byte[] Buffer)
{
FileStream fileStream = new FileStream(path, FileMode.Create);
BinaryWriter writer = new BinaryWriter(fileStream);
//Ecrire le chunk de base
writer.Write(Header.FileTypeID);
writer.Write(Header.FileLenght);
writer.Write(Header.MediaTypedID);
//Ecrire le chunck du format
writer.Write(Header.ChunkIDFormat);
writer.Write(Header.ChunkSizeFormat);
writer.Write(Header.FormatTag);
writer.Write(Header.Channels);
writer.Write(Header.Frequency);
writer.Write(Header.AverageBytesPerSec);
writer.Write(Header.BlockAlign);
writer.Write(Header.BitsPerSample);
//Ecrire le chunck de données
writer.Write(Header.ChunkIDData);
writer.Write(Header.ChunkSizeData);
foreach (byte dataPoint in Buffer)
{
writer.Write(dataPoint);
}
//Fermeture des streams
writer.Close();
fileStream.Close();
}
public PLYToSchematic(string path, int scale) : base(path, scale)
{
FileStream stream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);
DataHeader header = ReadDataHeader(new StreamReader(stream));
DataBody body;
Console.WriteLine("[LOG] Start reading PLY data...");
body = header.binary ? ReadDataBodyBinary(header, new BinaryReader(stream)) : ReadDataBodyAscii(header, new StreamReader(stream));
Console.WriteLine("[LOG] Done.");
List <Vector3> bodyVertices = body.vertices;
List <Color> bodyColors = body.colors;
Vector3 minX = bodyVertices.MinBy(t => t.X);
Vector3 minY = bodyVertices.MinBy(t => t.Y);
Vector3 minZ = bodyVertices.MinBy(t => t.Z);
float min = Math.Abs(Math.Min(minX.X, Math.Min(minY.Y, minZ.Z)));
for (int i = 0; i < bodyVertices.Count; i++)
{
bodyVertices[i] += new Vector3(min, min, min);
bodyVertices[i] = new Vector3((float)Math.Truncate(bodyVertices[i].X * scale), (float)Math.Truncate(bodyVertices[i].Y * scale), (float)Math.Truncate(bodyVertices[i].Z * scale));
}
HashSet <Vector3> set = new HashSet <Vector3>();
List <Vector3> vertices = new List <Vector3>();
List <Color> colors = new List <Color>();
Console.WriteLine("[LOG] Start to voxelize data...");
using (ProgressBar progressbar = new ProgressBar())
{
for (int i = 0; i < bodyVertices.Count; i++)
{
if (!set.Contains(bodyVertices[i]))
{
set.Add(bodyVertices[i]);
vertices.Add(bodyVertices[i]);
colors.Add(bodyColors[i]);
}
progressbar.Report(i / (float)bodyVertices.Count);
}
}
Console.WriteLine("[LOG] Done");
minX = vertices.MinBy(t => t.X);
minY = vertices.MinBy(t => t.Y);
minZ = vertices.MinBy(t => t.Z);
min = Math.Min(minX.X, Math.Min(minY.Y, minZ.Z));
for (int i = 0; i < vertices.Count; i++)
{
float max = Math.Max(vertices[i].X, Math.Max(vertices[i].Y, vertices[i].Z));
if (/*max - min < 8000 && */ max - min >= 0)
{
vertices[i] -= new Vector3(min, min, min);
_blocks.Add(new Block((ushort)vertices[i].X, (ushort)vertices[i].Y, (ushort)vertices[i].Z, colors[i].ColorToUInt()));
}
}
}
DataHeader ReadDataHeader(PclBinaryReader reader)
{
var data = new DataHeader();
// Magic number line ("ply")
string line = reader.ReadLine();
if (line != "ply")
{
throw new ArgumentException("Magic number ('ply') mismatch.");
}
// Read header contents.
while (true)
{
// Read a line and split it with white space.
line = reader.ReadLine();
if (line == "end_header")
{
break;
}
var col = line.Split(' ');
switch (col[0])
{
case "comment":
continue;
// Element declaration (unskippable)
case "element" when col[1] == "vertex":
public void Delete(int id)
{
DataHeader entity = this.GetEntity(id);
db.Entry(entity).State = System.Data.Entity.EntityState.Deleted;
db.SaveChanges();
}
/// <summary>
/// Pushes the changes into database.
/// </summary>
public string PushState(string prevStateRoot, string stateRoot, SingleState[] changedWallets)
{
DataHeader header = null;
if (prevStateRoot == null)
{
header = DataHeader.EmptyState();
}
else
{
header = ReadHeader(prevStateRoot);
}
var changes = new Dictionary <string, List <SingleState> >();
foreach (var wallet in changedWallets)
{
var index = GetIndexFromHash(wallet.key);
if (changes.ContainsKey(index) == false)
{
changes[index] = new List <SingleState>();
}
changes[index].Add(wallet);
}
foreach (var change in changes)
{
header.path[change.Key] = WriteStateBlob(change.Key, change.Value.ToArray());
}
return(WriteHeader(stateRoot, header));
}
public void initialize()
{
// thread safety
lock (lockInputReader) {
// check if there is still an inputreader open, if so close
// (is also done in configure, but just in case these do not follow each other)
if (inputReader != null)
{
inputReader.close();
inputReader = null;
inputHeader = null;
inputBufferRowSize = 0;
}
// open the input reader
string inputDatFile = inputFile + ".dat";
inputReader = new DataReader(inputDatFile);
inputReader.open();
// retrieve the header
inputHeader = inputReader.getHeader();
// copy the rowsize to a local variable
// (A copy because this way we do not have to (thread)lock the reader/header objects when we just want to read the data)
inputBufferRowSize = inputHeader.rowSize;
}
// initialize the input buffer and already fill it with the rows
initInputBuffer();
// flag the initialization as complete
initialized = true;
}
public DataHeader ReadDataHeader(BinaryReader reader)
{
DataHeader newDataHeader = new DataHeader();
newDataHeader.gridMinX = reader.ReadSingle();
newDataHeader.gridMinY = reader.ReadSingle();
newDataHeader.gridMaxX = reader.ReadSingle();
newDataHeader.gridMaxY = reader.ReadSingle();
newDataHeader.cellWidth = reader.ReadSingle();
newDataHeader.cellHeight = reader.ReadSingle();
newDataHeader.gridWidth = reader.ReadUInt32();
newDataHeader.gridHeight = reader.ReadUInt32();
newDataHeader.unknown0 = reader.ReadUInt32();
newDataHeader.reserved_00 = reader.ReadUInt32();
newDataHeader.reserved_01 = reader.ReadUInt32();
newDataHeader.reserved1 = reader.ReadUInt32();
newDataHeader.numFaces = reader.ReadUInt32();
newDataHeader.reserved2 = reader.ReadUInt32();
newDataHeader.numXTOBBs = reader.ReadUInt32();
newDataHeader.reserved3 = reader.ReadUInt32();
newDataHeader.numAABBs = reader.ReadUInt32();
newDataHeader.reserved4 = reader.ReadUInt32();
newDataHeader.numSpheres = reader.ReadUInt32();
newDataHeader.reserved5 = reader.ReadUInt32();
newDataHeader.numOBBs = reader.ReadUInt32();
newDataHeader.reserved6 = reader.ReadUInt32();
newDataHeader.numCylinders = reader.ReadUInt32();
newDataHeader.reserved7 = reader.ReadUInt32();
newDataHeader.numUnknownType = reader.ReadUInt32();
newDataHeader.unknown1 = reader.ReadUInt32();
return(newDataHeader);
}
public static void Convert(DataHeader header, string path)
{
using (FileStream fs = new FileStream(path, FileMode.Create))
{
DataSerializer.Serialize(fs, header);
}
}
private static DataBody ReadDataBodyAscii(DataHeader header, StreamReader reader)
{
DataBody data = new DataBody(header.vertexCount);
string line;
while ((line = reader.ReadLine()) != null)
{
string[] strings = line.Split(' ');
if (strings.Length > 6)
{
try
{
float x = float.Parse(strings[0], CultureInfo.InvariantCulture);
float y = float.Parse(strings[1], CultureInfo.InvariantCulture);
float z = float.Parse(strings[2], CultureInfo.InvariantCulture);
byte r = byte.Parse(strings[3], CultureInfo.InvariantCulture);
byte g = byte.Parse(strings[4], CultureInfo.InvariantCulture);
byte b = byte.Parse(strings[5], CultureInfo.InvariantCulture);
data.AddPoint(x, y, z, r, g, b);
}
catch (Exception e)
{
Console.WriteLine("[ERROR] Line not well formated (Only works with CloudCompare): " + line + " " + e.Message);
}
}
}
return(data);
}
//Mets à jour les infos du WAV
private void updateInfos(ref DataHeader header)
{
if (!wav.Passed)
{
MessageBox.Show(wav.Log + ".\nVeuillez sélectionné un autre fichier.", "Format du fichier", MessageBoxButton.OK, MessageBoxImage.Warning);
return;
}
lblFileName.Content = Filename.Substring(Filename.LastIndexOf('\\') + 1);
lblFormat.Content = new string(header.MediaTypedID, 0, 4);
lblSize.Content = Constants.SizeSuffix(header.FileLenght);
lblAudioFormat.Content = "PCM";
if (header.Channels > 1)
{
lblChannels.Content = "Stéréo";
}
else
{
lblChannels.Content = "Mono";
}
lblBitrate.Content = Constants.SizeSuffix(header.AverageBytesPerSec) + "/s";
lblSamplingRate.Content = header.BitsPerSample;
txtBlockLog.Text = wav.Log;
DrawSignal();
}
DataBody ReadDataBody(DataHeader header, FileStream stream)
{
var data = new DataBody(header.vertexCount);
float x = 0, y = 0, z = 0;
float nx = 0, ny = 0, nz = 0;
Byte r = 255, g = 255, b = 255, a = 255;
if (header.pcType == PlyType.Binary)
{
for (var i = 0; i < header.vertexCount; i++)
{
(x, y, z, r, g, b, a, nx, ny, nz) = ParseBinaryData(header, new BinaryReader(stream));
data.AddPoint(x, y, z, r, g, b, a, nx, ny, nz);
}
}
else if (header.pcType == PlyType.Ascii)
{
StreamReader reader = new StreamReader(stream);
reader.ReadLine();
reader.ReadLine();
for (var i = 0; i < header.vertexCount; i++)
{
(x, y, z, r, g, b, a, nx, ny, nz) = ParseAsciiData(header, reader);
data.AddPoint(x, y, z, r, g, b, a, nx, ny, nz);
}
}
return(data);
}
public override void OnIncommingData(DataHeader dataHeader, byte[] data)
{
_number += data.Length;
_times += 1;
string funName = MethodBase.GetCurrentMethod().Name;
WriteConsoleLog(_times + ":" + funName + " " + dataHeader + " " + _number);
}
public Message(RemotingPeer peer, RemotingManager remotingManager, Serializer serializer)
{
Serializer = serializer;
Peer = peer;
RemotingManager = remotingManager;
Header = new DataHeader(Serializer);
Flags = MessageFlags.None;
}
DataBody ReadDataBody(DataHeader header, BinaryReader reader)
{
var data = new DataBody(header.vertexCount);
float x = 0, y = 0, z = 0;
Byte r = 255, g = 255, b = 255, a = 255;
for (var i = 0; i < header.vertexCount; i++)
{
foreach (var prop in header.properties)
{
switch (prop)
{
case DataProperty.R8: r = reader.ReadByte(); break;
case DataProperty.G8: g = reader.ReadByte(); break;
case DataProperty.B8: b = reader.ReadByte(); break;
case DataProperty.A8: a = reader.ReadByte(); break;
case DataProperty.R16: r = (byte)(reader.ReadUInt16() >> 8); break;
case DataProperty.G16: g = (byte)(reader.ReadUInt16() >> 8); break;
case DataProperty.B16: b = (byte)(reader.ReadUInt16() >> 8); break;
case DataProperty.A16: a = (byte)(reader.ReadUInt16() >> 8); break;
case DataProperty.SingleX: x = reader.ReadSingle(); break;
case DataProperty.SingleY: y = reader.ReadSingle(); break;
case DataProperty.SingleZ: z = reader.ReadSingle(); break;
case DataProperty.DoubleX: x = (float)reader.ReadDouble(); break;
case DataProperty.DoubleY: y = (float)reader.ReadDouble(); break;
case DataProperty.DoubleZ: z = (float)reader.ReadDouble(); break;
case DataProperty.Data8: reader.ReadByte(); break;
case DataProperty.Data16: reader.BaseStream.Position += 2; break;
case DataProperty.Data32: reader.BaseStream.Position += 4; break;
case DataProperty.Data64: reader.BaseStream.Position += 8; break;
}
}
data.AddPoint(x, y, z, r, g, b, a);
}
return(data);
}
private DataHeader ReadHeader(string stateRoot)
{
var header = fdb.Read <DataHeader>($"root/{stateRoot}");
if (header == null)
{
return(DataHeader.EmptyState());
}
return(header);
}
private void DrawConnectingLine(int i, DataHeader header)
{
DataEntry a = _entries[i];
DataEntry b = _entries[i + 1];
float x = (i + 1) * _rect.width / HISTORY_BUFFER_LENGTH + _rect.xMin;
float ay = GetHeight(a, header);
float by = GetHeight(b, header);
DrawLine(x, ay, x, by);
}
public override void Parse(VoidPtr address)
{
//Initialize lists
_extraEntries = new List <MovesetEntry>();
_articles = new SortedList <int, MovesetEntry>();
_subActions = new BindingList <SubActionEntry>();
//Set header values
DataHeader *h = (DataHeader *)address; _hdr = *h;
_unk27 = _hdr.Unknown27;
_unk28 = _hdr.Unknown28;
_flags1 = _hdr.Flags1;
_flags2 = _hdr.Flags2;
bint *v = (bint *)address;
int[] sizes = MovesetFile.CalculateSizes(_root._dataSize, v, 27, true);
ParseScripts(v, sizes);
//Parse all data entries.
//If an offset is 0 (except for the attributes), the entry will be set to null.
_modelVis = Parse <ModelVisibility>(v[1]);
_attributes = Parse <AttributeList>(v[2], "Attributes");
_sseAttributes = Parse <AttributeList>(v[3]);
_misc = Parse <Miscellaneous>(v[4]);
_unknown7 = Parse <EntryList <Unknown7Entry> >(v[7], 8);
_actionInterrupts = Parse <ActionInterrupts>(v[8]);
_actionPre = Parse <EntryList <ActionPre> >(v[11], 4);
_anchoredItems = Parse <EntryList <ItemAnchor> >(v[16], sItemAnchor.Size);
_gooeyBomb = Parse <EntryList <ItemAnchor> >(v[17], sItemAnchor.Size);
_boneRef1 = Parse <EntryList <BoneIndexValue> >(v[18], 4, sizes[18] / 4);
_boneRef2 = Parse <BoneReferences2>(v[19]);
_entryOverrides = Parse <ActionOverrideList>(v[20]);
_exitOverrides = Parse <ActionOverrideList>(v[21]);
_unknown22 = Parse <Unknown22>(v[22]);
_boneFloats3 = Parse <EntryList <ItemAnchor> >(v[23], sItemAnchor.Size + 4);
_unknown24 = Parse <Unknown24>(v[24]);
//Parse extra offsets specific to this character
OffsetHolder o = ExtraDataOffsets.GetOffsets(_root.Character);
if (o != null)
{
o.Parse(this, address + DataHeader.Size);
}
int u = 0;
foreach (ArticleEntry e in _articles.Values)
{
e._index = u++;
}
}
public void TestSerializeNullException()
{
IGraphController graphController = new GraphController(null);
IStorage storage = null;
DataHeader header = new DataHeader();
Assert.Throws <ArgumentNullException>(() =>
{
header.Serialize(storage);
});
}
public static DataSet LoadDataSetFromFile(string fileName)
{
DataSet set = new DataSet();
DataHeader header = new DataHeader();
header.Driver = "Danny Bujna";
header.Location = "King Edward Park";
set.DataHeader = header;
set.DataLines = GetDataLinesFrom(fileName);
return set;
}
public void TestDeserilaizeOperationException()
{
IGraphController graphController = new GraphController(null);
IStorage storage = new BinaryStorage();
DataHeader header = new DataHeader();
storage.WriteUnsignedInteger(FieldCode.DataHeaderSignature, 21);
storage.Seek(0, SeekOrigin.Begin);
Assert.Throws <InvalidOperationException>(() =>
{
header.Deserialize(storage);
});
}
// Start is called before the first frame update
void Start()
{
bool couldReadHeader = DataHeader.TryReadHeader("Configuration.json", out DataHeader header);
IDataSource dataSource = null;
if (!couldReadHeader)
{
File.Create("Configuration.json");
header = new DataHeader();
header.Delimeter = ";";
header.DeltaTime = .1f;
header.DataPoints = new DataPointDefinition[2];
for (int i = 0; i < header.DataPoints.Length; i++)
{
header.DataPoints[i] = new DataPointDefinition();
header.DataPoints[i].X = i;
}
dataSource = new NetworkDataSource(3015, header);
}
else
{
switch (header.SourceType)
{
case DataSourceType.FILE:
dataSource = new FakeDataSource(header.SourceLocation);
break;
case DataSourceType.NETWORK:
dataSource = new NetworkDataSource(3015, header);
break;
case DataSourceType.SERIAL:
dataSource = new SerialDataSource(string.IsNullOrEmpty(header.SourceLocation) ? "Com3" : header.SourceLocation);
break;
}
}
//Sets up both the fake data source and the real data from the ardiuno
//fakeSource = new FakeDataSource("CLT Composite Beams Board1 2by10 Panel 1.ASC", 200);
//serialDataSource = new SerialDataSource("Com3", new string[] {
//"DASYLab - V 11.00.00",
//"Worksheet name: 6by10beamlayout",
//"Recording date: 7 / 1 / 2016, 4:52:39 PM",
//"Block length: 2",
//"Delta: 1.0 sec.",
//"Number of channels: 3",
//"Date;Measurement time[hh:mm:ss];voltage [V];voltage2 [V]; volage3 [V];"});
MainCollection = new Parser(dataSource);
MainCollection.start();
}
public static void ReadHeaders(Stream stream, out FmtHeader fmtHeader, out DataHeader dataHeader, out long dataStart)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (!BitConverter.IsLittleEndian)
{
throw new InvalidOperationException("Unsupported system endianness.");
}
if (!IsWavStream(stream))
{
throw new InvalidOperationException("Invalid WAV header.");
}
EngineBinaryReader engineBinaryReader = new EngineBinaryReader(stream);
fmtHeader = default(FmtHeader);
dataHeader = default(DataHeader);
dataStart = 0L;
stream.Position += 12L;
bool flag = false;
bool flag2 = false;
while (!flag || !flag2)
{
int num = engineBinaryReader.ReadInt32();
if (num == MakeFourCC("fmt "))
{
stream.Position -= 4L;
fmtHeader = engineBinaryReader.ReadStruct <FmtHeader>();
flag = true;
}
else if (num == MakeFourCC("data"))
{
stream.Position -= 4L;
dataHeader = engineBinaryReader.ReadStruct <DataHeader>();
dataStart = stream.Position;
flag2 = true;
}
else
{
int num2 = engineBinaryReader.ReadInt32();
stream.Position += num2;
}
}
if (fmtHeader.Type != 1 || fmtHeader.ChannelsCount < 1 || fmtHeader.ChannelsCount > 2 || fmtHeader.SamplingFrequency < 8000 || fmtHeader.SamplingFrequency > 48000 || fmtHeader.BitsPerChannel != 16)
{
throw new InvalidOperationException("Unsupported WAV format.");
}
}
/// <summary>
/// Sự kiện phát sinh khi có dữ liệu được gửi đến từ client
/// </summary>
/// <param name="dataHeader">Thông tin kết nối</param>
/// <param name="data">dữ liệu nhận được</param>
public override void OnIncommingData(DataHeader dataHeader, byte[] data)
{
try
{
BaseDevice baseDevice = GetDevice(string.Format("{0}:{1}", dataHeader.ClientIP, dataHeader.ClientPort));
if (baseDevice != null)
{
baseDevice.RaiseEventIncommingData(data);
}
}
catch (Exception ex)
{
Log.Error("Error while raise 'OnIncommingData' {0}", ex.ToString());
}
}
public override void Write(FdbFile writer)
{
writer.WriteObject(this);
writer.WriteObject(DataHeader);
if (Linked == default)
{
writer.WriteObject(-1);
}
else
{
writer.WriteObject(Linked);
}
DataHeader?.Write(writer);
Linked?.Write(writer);
}
public void TestSerializeDeserialize()
{
IGraphController graphController = new GraphController(null);
IStorage storage = new BinaryStorage();
DataHeader header1 = new DataHeader();
header1.DataSize = 21;
DataHeader header2 = new DataHeader();
header2.DataSize = 12;
header1.Serialize(storage);
storage.Seek(0, SeekOrigin.Begin);
header2.Deserialize(storage);
Assert.AreEqual(21, header2.DataSize);
}
public String DoWork(DataHeader h, String classWithNs, String methodName, string paramStr)
{
try
{
String v = WebRestService.InvokeBp(h, classWithNs, methodName, paramStr);
GuProxyService.Model.mServiceProxy res = JsonConvert.DeserializeObject <GuProxyService.Model.mServiceProxy>(v);
if (!string.IsNullOrEmpty(res.ErrorMessage))
{
throw new Exception(res.ErrorMessage);
}
return(v);
}
catch (Exception)
{
throw;
}
}
public void OnIncommingData(DataHeader dataHeader, byte[] data)
{
string log = string.Format("Receive Data From:{0}:{1} - Length:{2}", dataHeader.ClientIP,
dataHeader.ClientPort, data.Length);
AppendTcpLog(log);
var p = new SettextParametter(txtDlNhan, Encoding.UTF8.GetString(data));
var t = new Thread(ThreadSetText);
t.Start(p);
if (btnSaveBinaryFile.Tag.ToString() == "1")
{
_binaryWriter.Write(data);
_binaryWriter.Flush();
}
}
private Color GetColor(DataHeader header, DataEntry entry)
{
float value = header.GetValue(entry);
if (header.IsHighSeverity(entry))
{
return(_highSeverityTextColor);
}
else if (header.IsMediumSeverity(entry))
{
return(_mediumSeverityTextColor);
}
else
{
return(_normalTextColor);
}
}
public DataHeaderForRpc(DataHeader dataHeader)
{
Id = dataHeader.Id;
Name = dataHeader.Name;
Description = dataHeader.Description;
UnitPrice = dataHeader.UnitPrice;
UnitType = dataHeader.UnitType.ToString().ToLowerInvariant();
QueryType = dataHeader.QueryType.ToString().ToLowerInvariant();
MinUnits = dataHeader.MinUnits;
MaxUnits = dataHeader.MaxUnits;
Rules = new DataHeaderRulesForRpc(dataHeader.Rules);
Provider = new DataHeaderProviderForRpc(dataHeader.Provider);
File = dataHeader.File;
State = dataHeader.State.ToString().ToLowerInvariant();
TermsAndConditions = dataHeader.TermsAndConditions;
KycRequired = dataHeader.KycRequired;
}
DataBody ReadDataBody(DataHeader header, BinaryReader reader, int KNN)
{
var data = new DataBody(header.vertexCount);
float x = 0, y = 0, z = 0;
Byte r = 255, g = 255, b = 255, a = 255;
for (var i = 0; i < header.vertexCount; i++)
{
foreach (var prop in header.properties)
{
switch (prop)
{
case DataProperty.X: x = reader.ReadSingle(); break;
case DataProperty.Y: y = reader.ReadSingle(); break;
case DataProperty.Z: z = reader.ReadSingle(); break;
case DataProperty.R: r = reader.ReadByte(); break;
case DataProperty.G: g = reader.ReadByte(); break;
case DataProperty.B: b = reader.ReadByte(); break;
case DataProperty.A: a = reader.ReadByte(); break;
//case DataProperty.Size: size = reader.ReadSingle(); break;
case DataProperty.Data8: reader.ReadByte(); break;
case DataProperty.Data16: reader.BaseStream.Position += 2; break;
case DataProperty.Data32: reader.BaseStream.Position += 4; break;
}
}
data.AddPoint(x, y, z, r, g, b, a);
}
if (KNN > 0)
{
data.CalculatePointSize(header.vertexCount, KNN);
}
return(data);
}
public String DoWorkWithWebGet()
{
NameValueCollection nvc = HttpUtility.ParseQueryString(HttpContext.Current.Request.Url.Query);
String classWithNs = "";
String methodName = "";
String paramStr = "";
DataHeader h = null;
classWithNs = nvc["classWithNs"];
methodName = nvc["methodName"];
string v = WebRestService.InvokeBpWithQueryParam(h, classWithNs, methodName, paramStr, nvc);
//String v = WebRestService.InvokeBp(h, classWithNs, methodName, paramStr);
return(v);
}
public WAV(string name, Stream wavFile)
{
//Constructeur
Name = name;
StreamWAV = wavFile;
Header = new DataHeader();
Log = ReadBuffer();
if (Passed)
{
Samples = new float[Buffer.Length];
for (int i = 0; i < Buffer.Length - 1; i++)
{
Samples[i] = BitConverter.ToInt16(Buffer, i);
}
}
Player = new WAVPlay(name);
}
