public void OnLoad(MMF.Sprite.D2DSpriteBatch batch)
{
GameContext.InitializePlayerDescriptions(batch);
_geometry = new PathGeometry(GameContext.RenderContext.D2DFactory);
GeometrySink geometrySink = _geometry.Open();
geometrySink.SetFillMode(FillMode.Winding);
geometrySink.BeginFigure(new Point(50, 580), FigureBegin.Filled);
geometrySink.AddLine(new Point(20, 600));
geometrySink.AddLine(new Point(50, 620));
geometrySink.EndFigure(FigureEnd.Closed);
geometrySink.Close();
_geometry_2 = new PathGeometry(GameContext.RenderContext.D2DFactory);
GeometrySink geometrySink_2 = _geometry_2.Open();
geometrySink_2.SetFillMode(FillMode.Winding);
geometrySink_2.BeginFigure(new Point(520, 580), FigureBegin.Filled);
geometrySink_2.AddLine(new Point(550, 600));
geometrySink_2.AddLine(new Point(520, 620));
geometrySink_2.EndFigure(FigureEnd.Closed);
geometrySink_2.Close();
col_1 = batch.CreateSolidColorBrush(Color.FromArgb(255, 255, 255, 255));
col_2 = batch.CreateSolidColorBrush(Color.FromArgb(120, 255, 0, 0));
col_3 = batch.CreateSolidColorBrush(Color.FromArgb(120, 0, 0, 255));
col_4 = batch.CreateSolidColorBrush(Color.FromArgb(120, 0, 255, 0));
col_5 = batch.CreateSolidColorBrush(Color.FromArgb(120, 0, 0, 0));
// bitmap = batch.CreateBitmap(@playerDescriptions[currentIndex].image);
format_1 = batch.CreateTextformat("Meiryo UI", 60);
format_2 = batch.CreateTextformat("Meiryo UI", 100);
isInitialized = true;
}
public void Dispose()
{
if (MMF != null)
{
MMF.Dispose();
}
}
public SharedMessageQueue(string file)
{
File = file;
if (System.IO.File.Exists(File))
{
Log("Opening Queue File");
MMF = MemoryMappedFile.CreateFromFile(File, FileMode.Open, "communicator", MaxSize);
Accessor = MMF.CreateViewAccessor(0, ReservedSize);
Log("Opened Queue File");
}
else
{
Log("Creating Queue File");
MMF = MemoryMappedFile.CreateFromFile(File, FileMode.Create, "communicator", MaxSize);
Accessor = MMF.CreateViewAccessor(0, ReservedSize);
Front = ReservedSize;
Rear = ReservedSize;
IsEmpty = true;
IsFull = false;
Log("Created Queue File");
}
Log("Front:{0}, Rear:{1}", Front, Rear);
}
static void ImageLoader()
{
byte[] receivedImage;
receivedImageFile = new MMF();
receivedImageFile.OpenExisting(mmfSourceFileName);
receivedImage = Convert.FromBase64String(receivedImageFile.ReadContent(MMF.DataType.DataString));
Program.receivedImage = new Image <Bgra, byte>(new Bitmap(new MemoryStream(receivedImage)));
}
public bool Enqueue(int level, string msg)
{
var c = Encoding.UTF8.GetBytes(msg);
var data = new byte[c.Length + HeaderSize];
var s = new MemoryStream(data);
using (var sw = new BinaryWriter(s))
{
sw.Write(level); // 4
sw.Write(DateTime.Now.Ticks); // 8
sw.Write(c.Length); // 4
sw.Write(c);
}
using (var stream = MMF.CreateViewStream())
{
stream.Position = Front;
if (IsFull)
{
// No space
Log("No space for writing data");
return(false);
}
else
{
if (Front + data.Length < stream.Length)
{
// Enough space to go
stream.Write(data, 0, data.Length);
Front = stream.Position;
Log("Enough space, enqueue data");
}
else
{
// No enough space, break into two parts
var firstLen = (int)(stream.Length - Front);
var secondLen = data.Length - firstLen;
stream.Write(data, 0, firstLen);
stream.Position = ReservedSize; // reset to begin
stream.Write(data, firstLen - 1, secondLen);
Front = stream.Position;
Log("Split data and enqueue");
}
IsEmpty = false;
}
// 1. Front is catching up Rear in next cycle
// 2. Front is near the end of the stream, and remaining data in the head is not enough
if ((Rear > Front && Rear - Front < HeaderSize) || (stream.Length - Front - 1 + (Rear - ReservedSize)) < HeaderSize)
{
IsFull = true;
}
Log("Front:{0}, Rear:{1}", Front, Rear);
return(true);
}
}
static void ImageLoader()
{
imageFile = new MMF();
imageFile.OpenExisting(mmfFileName);
using (var ms = new MemoryStream(Convert.FromBase64String(imageFile.ReadContent(MMF.DataType.DataString))))
{
receivedImage = new Image <Bgra, byte>(new Bitmap(ms));
}
}
void Kursor3DTestThread()
{
// TODO: Implement actAsModelerModule
ThreadHelperClass.SetText(this, lblStatusValue, "Thread started. Loading images from selected folder to memory...");
ThreadHelperClass.SetText(this, lblStatusValue, "Thread started. Loading images from selected folder to memory...");
#region Test image loader
Bitmap[] sourceImage;
string[] Files = Directory.GetFiles(cursor3DSourceImage, "*.png");
sourceImage = new Bitmap[Files.Length];
for (int fileNumber = 0; fileNumber < Files.Length; fileNumber++)
{
sourceImage[fileNumber] = new Bitmap(Files[fileNumber]);
}
#endregion Test image loader
ThreadHelperClass.SetText(this, lblStatusValue, "Images loaded. " + Files.Length + " files were added to memory");
bool isExitRequested = false;
MMF mappedFile = new MMF();
mappedFile.CreateNewFile("Kursor3DSourceImage", 10000000);
int position = 0;
do
{
Stopwatch overalPerformance = new Stopwatch();
overalPerformance.Start();
// Create preview of loaded image
ThreadHelperClass.SetImage(this, picImagePreview, sourceImage[position]);
ThreadHelperClass.SetText(this, lblStatusValue, "Now previewing image: " + Files[position]);
position++;
if (position == Files.Length)
{
position = 0;
}
#region Receiver threat
receiverThread = new Thread(ResultReceiver);
receiverThread.Start();
#endregion Receiver threat
ThreadHelperClass.SetText(this, lblStatusValue, "Writing image to memory-mapped file");
// Convert image to array and save to tempImage
Stopwatch imageConversionWatcher = new Stopwatch();
imageConversionWatcher.Start();
#region Image converter
byte[] tempImage;
using (var ms = new MemoryStream())
{
sourceImage[position].Save(ms, sourceImage[position].RawFormat);
tempImage = ms.ToArray();
}
#endregion Image converter
imageConversionWatcher.Stop();
ThreadHelperClass.SetText(this, lblImageConversionPerformaceValue, imageConversionWatcher.ElapsedMilliseconds.ToString() + "ms");
Stopwatch MMFWatcher = new Stopwatch();
MMFWatcher.Start();
// Write the image to memory-mapped file
mappedFile.AddInformation(Convert.ToBase64String(tempImage));
MMFWatcher.Stop();
ThreadHelperClass.SetText(this, lblMMFPerformanceValue, MMFWatcher.ElapsedMilliseconds.ToString() + "ms");
ThreadHelperClass.SetText(this, lblStatusValue, "File writen. Sending notification to Cursor 3D");
// Notify Kursor3D Module about the image
SendReport("Kursor3DImageNotifier");
ThreadHelperClass.SetText(this, lblStatusValue, "Module connected. Now waiting for the module to complete the process");
// Wait for receiver thread to complete
if (receiverThread.IsAlive)
{
receiverThread.Join();
}
receiverThread = null;
#region UI setter
ThreadHelperClass.SetText(this, lblStatusValue, "Module has finished the work. Writing the received values");
ThreadHelperClass.SetText(this, lblXPositionValue, x.ToString());
ThreadHelperClass.SetText(this, lblYPositionValue, y.ToString());
ThreadHelperClass.SetText(this, lblZPositionValue, z.ToString());
ThreadHelperClass.SetText(this, lblGestureTypeValue, gestureType);
overalPerformance.Stop();
ThreadHelperClass.SetText(this, lblOveralPerformanceValue, overalPerformance.ElapsedMilliseconds.ToString() + "ms");
ThreadHelperClass.SetText(this, lblKursor3DOverallPerformanceValue, kursor3DOverallPerformance.ToString() + "ms");
ThreadHelperClass.SetText(this, lblKursor3DFindHandThreadPerformanceValue, kursor3DFindHandPerformance.ToString() + "ms");
ThreadHelperClass.SetText(this, lblKursor3DFindDepthThreadPerformanceValue, kursor3DFindDepthPerformance.ToString() + "ms");
ThreadHelperClass.SetText(this, lblKursor3DGestureRecognitionThreadPerformanceValue, kursor3DgestureRecognitionPerformance.ToString() + "ms");
#endregion UI setter
} while (!isExitRequested);
}
static void ImageWriter()
{
sentImageFile = new MMF();
sentImageFile.CreateNewFile(mmfProcessedFileName, 10000000);
sentImageFile.AddInformation(Convert.ToBase64String(processedImage.Bytes));
}
public void RenderSprite(MMF.Sprite.D2DSpriteBatch batch)
{
if (PlayerContext.HandOperationChecker != null && PlayerContext.HandOperationChecker.isAcceptButtonPressed())
{
return;
}
var playerDescriptions = GameContext.playerDescriptions;
// batch.DWRenderTarget.FillRectangle(col_1, batch.FillRectangle);
batch.DWRenderTarget.FillRectangle(col_2, new Rectangle(0, 0, 1000, 250));//キャラクターボックス
batch.DWRenderTarget.DrawText("CHARACTER", format_1, new Rectangle(60, 10, 700, 100), col_1);
batch.DWRenderTarget.DrawText(playerDescriptions[currentIndex].charactorName, format_2, new Rectangle(250, 100, 1000, 100), col_1);
batch.DWRenderTarget.DrawBitmap(playerDescriptions[currentIndex].image, new Rectangle(60, 350, 450, 450));
batch.DWRenderTarget.FillGeometry(_geometry, col_1);
batch.DWRenderTarget.FillGeometry(_geometry_2, col_1);
int skbox_x = 560, skbox_y = 300;
int skbox_w = 1000 - skbox_x, skbox_h = 900 - skbox_y;
batch.DWRenderTarget.FillRectangle(col_3, new Rectangle(skbox_x, skbox_y, skbox_w, skbox_h));//スキルボックス
batch.DWRenderTarget.DrawText("SKIL", format_1, new Rectangle(skbox_x + 100, skbox_y, 500, 100), col_1);
batch.DWRenderTarget.DrawText("Ａ:", format_1, new Rectangle(skbox_x + 20, skbox_y + 150, 500, 100), col_1);
batch.DWRenderTarget.DrawText("Ｂ:", format_1, new Rectangle(skbox_x + 20, skbox_y + 300, 500, 100), col_1);
batch.DWRenderTarget.DrawText("Ｃ:", format_1, new Rectangle(skbox_x + 20, skbox_y + 450, 400, 100), col_1);
batch.DWRenderTarget.DrawText(playerDescriptions[currentIndex].skillName_1, format_1, new Rectangle(skbox_x + 120, skbox_y + 150, 500, 100), col_1);
batch.DWRenderTarget.DrawText(playerDescriptions[currentIndex].skillName_2, format_1, new Rectangle(skbox_x + 120, skbox_y + 300, 500, 100), col_1);
batch.DWRenderTarget.DrawText(playerDescriptions[currentIndex].skillName_3, format_1, new Rectangle(skbox_x + 120, skbox_y + 450, 500, 100), col_1);
}
private void readCalcResultAsync(IntPtr Chandle, int dataSize)
{
//-1代表子进程写入共享内存失败
if (dataSize == -1)
{
Console.WriteLine(string.Format("Write mmf {0} failed", Chandle));
System.Environment.Exit(2);
}
//0代表当前共享内存中不存在数据，则直接返回，且让++this.procDoneNum
if (dataSize == 0)
{
Console.WriteLine(string.Format("当前批{0}没有数据", Chandle));
if (++this.procDoneNum == this.processNum)
{
Task.Run(() => {
writeResToDb();
});
}
return;
}
DateTime t1, t2;
t1 = DateTime.Now;
Console.WriteLine(string.Format("read params :child handle = {0}, data size = {1}", Chandle, dataSize));
string shareName = this.getMMFName(Chandle);
Console.WriteLine(string.Format("read child outcome :{0}", shareName));
IntPtr mmf = IntPtr.Zero;
try
{
mmf = MMF.OpenFileMapping(MMF.FileMapAccess.FileMapRead, false, shareName);
Console.WriteLine("open file ...");
}
catch (Exception e)
{
//MessageBox.Show(string.Format("open mmf {0} failed, error : {1}", shareName, e.Message));
Console.WriteLine(string.Format("open mmf {0} failed, error : {1}", shareName, e.Message));
System.Environment.Exit(2);
}
if (IntPtr.Zero == mmf)
{
//MessageBox.Show(string.Format("共享内存<{0}>打开失败，错误信息编号：{1}", shareName, MMF.GetLastError()));
Console.WriteLine(string.Format("共享内存<{0}>打开失败，错误信息编号：{1}", shareName, MMF.GetLastError()));
System.Environment.Exit(2);
return;
}
IntPtr reader = IntPtr.Zero;
try
{
reader = MMF.MapViewOfFile(mmf, MMF.FileMapAccess.FileMapRead, 0, 0, (uint)dataSize);
Console.WriteLine("map view ...");
}
catch (Exception e)
{
Console.WriteLine("map view failed");
System.Environment.Exit(2);
return;
}
if (reader == IntPtr.Zero)
{
//MessageBox.Show(string.Format("共享内存<{0}>映射失败，错误信息编号：{1}", shareName, MMF.GetLastError()));
Console.WriteLine(string.Format("共享内存<{0}>映射失败，错误信息编号：{1}", shareName, MMF.GetLastError()));
System.Environment.Exit(2);
return;
}
IntPtr tp = IntPtr.Zero;
Type type = typeof(MMFGSStruct);
int ssize = Marshal.SizeOf(type);
Console.WriteLine("ssize = " + ssize);
//tp = new IntPtr(reader.ToInt64());
MMFGSStruct data = new MMFGSStruct();
long sp = reader.ToInt64();
for (int dsize = 0; dsize < dataSize; dsize += ssize)
{
try
{
tp = new IntPtr(sp + dsize);
data = (MMFGSStruct)Marshal.PtrToStructure(tp, typeof(MMFGSStruct));
// convertFromMMFGSStruct 将共享内存传递的计算结果转换为GridStrength
this.MultiTasksGridStrengths.Add(convertFromMMFGSStruct(data));
}
catch (Exception e)
{
Console.WriteLine(string.Format("read error : tp = {0}, dsize = {1}, msg = {2}", tp.ToInt64(), dsize, e.Message));
System.Environment.Exit(2);
//MessageBox.Show(string.Format("read error : tp = {0}, dsize = {1}, msg = {2}", tp.ToInt32(), dsize, e.Message));
}
}
Console.WriteLine("after read....");
MMF.UnmapViewOfFile(reader);
MMF.CloseHandle(mmf);
mmf = reader = IntPtr.Zero;
t2 = DateTime.Now;
Console.WriteLine(string.Format("read {0} done. now total : {1}, using time: {2}", shareName, this.MultiTasksGridStrengths.Count, (t2 - t1).TotalMilliseconds));
Console.WriteLine("**********************************************************************");
this.procDoneNum++;
Console.WriteLine(String.Format("已处理{0}/{1}个进程", this.procDoneNum, this.processNum));
Console.WriteLine("**********************************************************************");
//this.outGSs();
//if (++this.procDoneNum == Math.Min(this.maxProcNum, this.processNum - this.procDoneNum1))
if (this.procDoneNum == this.processNum)
{
Task.Run(() => {
writeResToDb();
});
RedisMq.Pub("rayTrace_finish", this.cellInfo.eNodeB);
}
}
// 2019.5.22
private void readReRayResult(IntPtr Chandle, int dataSize)
{
//-1代表子进程写入共享内存失败
if (dataSize == -1)
{
Console.WriteLine(string.Format("Write mmf {0} failed", Chandle));
errorExit();
}
if (dataSize == 0)
{
Console.WriteLine(string.Format("当前批{0}没有数据", Chandle));
//将写入数据库操作剥离
if (++this.procDoneNum1 == this.processNum)
{
writeReRayToDb();
}
return;
}
string shareName = this.getMMFName(Chandle) + "_ReRay";
IntPtr mmf = IntPtr.Zero;
try
{
mmf = MMF.OpenFileMapping(MMF.FileMapAccess.FileMapRead, false, shareName);
}
catch (Exception e)
{
Console.WriteLine(string.Format("open mmf {0} failed, error : {1}", shareName, e.Message));
errorExit();
}
if (IntPtr.Zero == mmf)
{
Console.WriteLine(string.Format("共享内存<{0}>打开失败，错误信息编号：{1}", shareName, MMF.GetLastError()));
errorExit();
}
//共享内存打开成功通知
Console.WriteLine(string.Format("read reRay................. open mmf {0} success", shareName));
IntPtr reader = IntPtr.Zero;
try
{
reader = MMF.MapViewOfFile(mmf, MMF.FileMapAccess.FileMapRead, 0, 0, (uint)dataSize);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
errorExit();
}
if (reader == IntPtr.Zero)
{
Console.WriteLine(string.Format("共享内存<{0}>映射失败，错误信息编号：{1}", shareName, MMF.GetLastError()));
errorExit();
}
IntPtr tp = IntPtr.Zero;
Type type = typeof(MMFReRayStruct);
int ssize = Marshal.SizeOf(type);
tp = new IntPtr(reader.ToInt64());
MMFReRayStruct data = new MMFReRayStruct();
long sp = reader.ToInt64();
for (int dsize = 0; dsize < dataSize; dsize += ssize)
{
try
{
tp = new IntPtr(sp + dsize);
data = (MMFReRayStruct)Marshal.PtrToStructure(tp, typeof(MMFReRayStruct));
this.MultiTasksReRay.Add(data);
}
catch (Exception e)
{
Console.WriteLine(string.Format("read error : tp = {0}, dsize = {1}, msg = {2}", tp.ToInt64(), dsize, e.Message));
}
}
MMF.UnmapViewOfFile(reader);
MMF.CloseHandle(mmf);
mmf = reader = IntPtr.Zero;
//共享内存打开成功通知
Console.WriteLine(string.Format("add reRay to MultiTasksReRay success..................................."));
//将写入数据库操作剥离
if (++this.procDoneNum1 == this.processNum)
{
writeReRayToDb();
}
}
void MainFunction()
{
ThreadHelperClass.SetText(this, lblStatusValue, "Loading sample images to memory...");
SourceImagesLoader(txtSampleImagesFolderLocation.Text);
if (isSampleImageFolderEmpty)
{
ThreadHelperClass.SetText(this, lblStatus, "The selected folder has no images or the images is not supported");
}
else
{
ThreadHelperClass.SetText(this, lblStatusValue, "Loading finished. " + PTAMSourceImages.Length + " images were loaded into memory.");
}
Thread.Sleep(100);
ThreadHelperClass.SetText(this, lblStatusValue, "Preparing for sending...");
MMF mappedFile = new MMF();
mappedFile.CreateNewFile(PTAMModuleSourceImageFileName, 10000000);
int position = 0;
do
{
Stopwatch overallPerformance = new Stopwatch();
overallPerformance.Start();
// Create preview of loaded image
ThreadHelperClass.SetImage(this, imgImagePreview, PTAMSourceImages[position]);
ThreadHelperClass.SetText(this, lblStatusValue, "Now previewing image: " + fileNames[position]);
position++;
if (position == fileNames.Length)
{
position = 0;
}
#region Receiver threat
receiverThread = new Thread(ResultReceiver);
receiverThread.Start();
#endregion Receiver threat
ThreadHelperClass.SetText(this, lblStatusValue, "Writing image to memory-mapped file");
#region Image converter
// Convert image to array and save to tempImage
Stopwatch imageConversionWatcher = new Stopwatch();
imageConversionWatcher.Start();
byte[] tempImage;
using (var ms = new MemoryStream())
{
PTAMSourceImages[position].Save(ms, PTAMSourceImages[position].RawFormat);
tempImage = ms.ToArray();
}
imageConversionWatcher.Stop();
testerImageConversionPerformance = imageConversionWatcher.ElapsedMilliseconds;
#endregion Image converter
#region Memory-Mapped File writing
Stopwatch MMFWatcher = new Stopwatch();
MMFWatcher.Start();
// Write the image to memory-mapped file
mappedFile.AddInformation(Convert.ToBase64String(tempImage));
MMFWatcher.Stop();
testerMemoryMappedFilePerformance = MMFWatcher.ElapsedMilliseconds;
#endregion Memory-Mapped File writing
ThreadHelperClass.SetText(this, lblStatusValue, "File writen. Sending notification to PTAM Module");
// Notify Kursor3D Module about the image
SendReport(PTAMModuleNamedPipeSendingChannel);
ThreadHelperClass.SetText(this, lblStatusValue, "Module connected. Now waiting for the module to complete the process");
// Wait for receiver thread to complete
if (receiverThread.IsAlive)
{
receiverThread.Join();
}
receiverThread = null;
ThreadHelperClass.SetText(this, lblStatusValue, "Module has finished the work. Writing the received values");
#region UI setter
#region Pose
#region Position
ThreadHelperClass.SetText(this, lblPositionXValue, receivedXPosition.ToString());
ThreadHelperClass.SetText(this, lblPositionYValue, receivedYPosition.ToString());
ThreadHelperClass.SetText(this, lblPositionZValue, receivedZPosition.ToString());
#endregion Position
#region Orientation
ThreadHelperClass.SetText(this, lblOrientationXValue, receivedXOrientation.ToString());
ThreadHelperClass.SetText(this, lblOrientationYValue, receivedYOrientation.ToString());
ThreadHelperClass.SetText(this, lblOrientationZValue, receivedZOrientation.ToString());
#endregion Orientation
#endregion Pose
#region Points
ThreadHelperClass.SetText(this, lblTotalPointCreatedValue, totalPointsCreated.ToString());
#endregion Points
overallPerformance.Stop();
testerOverallPerformance = overallPerformance.ElapsedMilliseconds;
ThreadHelperClass.SetText(this, lblOverallPerformanceValue, testerOverallPerformance.ToString() + "ms");
ThreadHelperClass.SetText(this, lblMemoryMappedFilePerformanceValue, testerMemoryMappedFilePerformance.ToString() + "ms");
ThreadHelperClass.SetText(this, lblImageConversionPerformanceValue, testerImageConversionPerformance.ToString() + "ms");
ThreadHelperClass.SetText(this, lblPTAMModuleOverallPerformanceValue, PTAMModuleOverallPerformance.ToString() + "ms");
ThreadHelperClass.SetText(this, lblPTAMModuleTrackingPerformanceValue, PTAMTrackingPerformance.ToString() + "ms");
ThreadHelperClass.SetText(this, lblPTAMModuleMappingPerformanceValue, PTAMMappingPerformance.ToString() + "ms");
ThreadHelperClass.SetText(this, lblPTAMModuleImageConversionPerformanceValue, PTAMImageConversionPerformance.ToString() + "ms");
ThreadHelperClass.SetText(this, lblPTAMModuleMemoryMappedFileReadingPerformanceValue, PTAMMemoryMappedFileReadingPerformance.ToString() + "ms");
#endregion UI setter
} while (!isExitRequested);
}
public SharedMessage Dequeue()
{
using (var stream = MMF.CreateViewStream())
{
if (IsEmpty)
{
Log("No Data");
return(null);
}
else
{
using (var sr = new BinaryReader(stream))
{
stream.Position = Rear;
var header = new byte[HeaderSize];
if (stream.Length - Rear >= HeaderSize)
{
header = sr.ReadBytes(HeaderSize);
}
else
{
var firstLen = (int)(stream.Length - stream.Position);
var secondLen = HeaderSize - firstLen;
var header1 = sr.ReadBytes(firstLen);
stream.Position = ReservedSize;
var header2 = sr.ReadBytes(secondLen);
Array.Copy(header1, header, firstLen);
Array.Copy(header2, 0, header, firstLen - 1, secondLen);
}
var level = BitConverter.ToInt32(header, 0);
var time = new DateTime(BitConverter.ToInt64(header, 4));
var len = BitConverter.ToInt32(header, 12);
var msg = new byte[len];
if (stream.Position + len <= stream.Length)
{
msg = sr.ReadBytes(len);
}
else
{
var firstLen = (int)(stream.Length - stream.Position);
var secondLen = len - firstLen;
var msg1 = sr.ReadBytes(firstLen);
stream.Position = ReservedSize;
var msg2 = sr.ReadBytes(secondLen);
Array.Copy(msg1, msg, firstLen);
Array.Copy(msg2, 0, msg, firstLen - 1, secondLen);
}
Rear = stream.Position;
IsFull = false;
// 1. Rear is catching up Front
// 2. Rear is near the end of the stream, the remaining data is not enough
if (Front - Rear < HeaderSize || (stream.Length - Rear - 1 + (Front - ReservedSize)) < HeaderSize)
{
IsEmpty = true;
}
Log("Front:{0}, Rear:{1}", Front, Rear);
var message = Encoding.UTF8.GetString(msg);
Log("Level:{0}, Time:{1}, Message:{2}", level, time, message);
return(new SharedMessage()
{
Level = level,
Timestamp = time,
Message = message
});
}
}
}
}
void ModelerThread()
{
ThreadHelperClass.SetText(this, lblStatusValue, "Requesting the HUB resolution...");
bool isExitRequested = false;
char receivedCode;
NamedPipesServer imageNotifier = new NamedPipesServer();
MMF ImageData;
Bitmap imageReceived;
#region Screen Resolution Request
int width;
int height;
// Connect for first time check for resolution used by main program
NamedPipesServer server = new NamedPipesServer();
server.CreateNewServerPipe("res-pipe", NamedPipesServer.PipeDirection.DirectionInOut, NamedPipesServer.SendMode.MessageMode);
server.WaitForConnection();
string resolution = server.ReadMessage();
// Separate screen width and height
string[] res = resolution.Split('x');
width = Convert.ToInt32(res[0]);
height = Convert.ToInt32(res[1]);
string receivedResolution = "Connected client resolution: " + width + " x " + height;
ThreadHelperClass.SetText(this, lblStatusValue, "HUB's resolution received");
ThreadHelperClass.SetText(this, lblScreenResolutionValue, receivedResolution);
#endregion Screen Resolution Request
bool isFirstTime = true;
do
{
ThreadHelperClass.SetText(this, lblStatusValue, "Waiting new notification...");
try
{
// Memory-mapped file access
server.CreateNewServerPipe("ImageNotifier", NamedPipesServer.PipeDirection.DirectionInOut, NamedPipesServer.SendMode.ByteMode);
server.WaitForConnection();
if (server.ReadByte() == (char)'y')
{
ThreadHelperClass.SetText(this, lblStatusValue, "Receiving image...");
byte[] file = null;
Console.WriteLine('y');
// Load image from Memory-mapped file and display as texture for model.
MMF mappedFile = new MMF();
mappedFile.OpenExisting("MapTest");
file = Convert.FromBase64String(mappedFile.ReadContent(MMF.DataType.DataString));
using (var ms = new MemoryStream(file))
{
imageReceived = new Bitmap(ms);
}
ThreadHelperClass.SetImage(this, imgTesterPreviewImage, imageReceived);
}
}
catch (Exception err)
{
throw;
}
server.Disconnect();
server.ClosePipe();
//try
//{
// imageNotifier.CreateNewServerPipe("test-pipe", NamedPipesServer.PipeDirection.DirectionInOut, NamedPipesServer.SendMode.ByteMode);
// imageNotifier.WaitForConnection();
// receivedCode = (char)imageNotifier.ReadByte();
// imageNotifier.WaitForPipeDrain();
// if (receivedCode == 'x')
// isExitRequested = true;
// else
// isExitRequested = false;
// if (receivedCode == 'y')
// {
// ThreadHelperClass.SetText(this, lblStatusValue, "New notification. Receiving...");
// byte[] file = null;
// // Load image from Memory-mapped file
// MMF mappedFile = new MMF();
// mappedFile.OpenExisting("MapTest");
// file = Convert.FromBase64String(mappedFile.ReadContent(MMF.DataType.DataString));
// using (var ms = new MemoryStream(file))
// {
// imageReceived = new Bitmap(ms);
// }
// ThreadHelperClass.SetImage(this, previewImage, imageReceived);
// }
//}
//catch (Exception err)
//{
// throw;
//}
//server.Disconnect();
//server.ClosePipe();
} while (!isExitRequested);
}
