public void EnumConvertion()
{
var db = DatabaseGenerator.Get();
db.Setting.Serialization.SerializeEnumAsInteger = false;
var stringValue = new DocumentSerializer(db).SerializeWithoutReader(ProductStatus.Available);
Assert.Equal(stringValue, "\"Available\"");
db.Setting.Serialization.SerializeEnumAsInteger = true;
var integerValue = new DocumentSerializer(db).SerializeWithoutReader(ProductStatus.SoldOut);
Assert.Equal(integerValue, "1");
}
public void CustomConverter()
{
var db = DatabaseGenerator.Get();
db.Setting.Serialization.Converters.Add(new StringEnumConverter());
var stringValue = new DocumentSerializer(db).SerializeWithoutReader(ProductStatus.Available);
Assert.Equal(stringValue, "\"Available\"");
db.Setting.Serialization.Converters.Clear();
var integerValue = new DocumentSerializer(db).SerializeWithoutReader(ProductStatus.Available);
Assert.Equal(integerValue, "0");
}
protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
var jObject = data as JObject;
if (jObject != null)
{
var streamWriter = new StreamWriter(stream);
await streamWriter.WriteAsync(jObject.ToString(Formatting.None)).ConfigureAwait(false);
await streamWriter.FlushAsync().ConfigureAwait(false);
}
else
{
var docSerializer = new DocumentSerializer(db);
var streamWriter = new StreamWriter(stream);
var jsonWriter = new JsonTextWriter(streamWriter);
var serializer = docSerializer.CreateJsonSerializer();
serializer.Serialize(jsonWriter, data);
await streamWriter.FlushAsync().ConfigureAwait(false);
}
}
protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
var jObject = data as JObject;
if (jObject != null)
{
var streamWriter = new StreamWriter(stream);
var jsonWriter = new JsonTextWriter(streamWriter);
jObject.WriteTo(jsonWriter);
await streamWriter.FlushAsync().ConfigureAwait(false);
}
else
{
var docSerializer = new DocumentSerializer(db);
var streamWriter = new StreamWriter(stream);
var jsonWriter = new JsonTextWriter(streamWriter);
var serializer = docSerializer.CreateJsonSerializer();
serializer.Serialize(jsonWriter, data);
await streamWriter.FlushAsync().ConfigureAwait(false);
}
}
public async Task <TypeRelationshipDocument> AnalyzeInheritanceAsync(string assemblyLocation, bool ignoreDotNetTypes, TypeDescriptor typeToAnalyse, CancellationToken cancellationToken)
{
var msg = new GetInheritanceGraphMessage
{
IgnoreDotNetTypes = ignoreDotNetTypes,
AssemblyLocation = assemblyLocation,
TypeToAnalyze = typeToAnalyse
};
var response = await this.ProcessAsync(typeof(InheritanceActor), msg, cancellationToken);
if (response is InheritanceGraphMessage m)
{
var serializer = new DocumentSerializer();
return(serializer.Deserialize <TypeRelationshipDocument>(m.Document));
}
else
{
return(null);
}
}
public ContactVariableProviderTests()
{
ContactExtension = Substitute.For <IContactExtension>();
Logger = Substitute.For <ILogger>();
Configuration = Substitute.For <IConfiguration>();
Application = Substitute.For <Application>();
InputContext = new Dictionary <string, object>();
Context.InputContext.Returns(InputContext);
Contact = new Contact()
{
Identity = "*****@*****.**",
Name = "John Doe",
Address = "184 Alpha Avenue"
};
ContactExtension.GetAsync(Contact.Identity, CancellationToken).Returns(Contact);
Context.UserIdentity.Returns(Contact.Identity);
Context.OwnerIdentity.Returns(new Identity("application", "domain.com"));
Application.Identifier = "application";
Application.Domain = "domain.com";
DocumentSerializer = new DocumentSerializer(new DocumentTypeResolver());
}
private async Task <DocIdGenerator> CreateDocIdGenerator()
{
if (_file.Length == 0)
{
return(new DocIdGenerator(0));
}
var initialPos = _file.Position;
try
{
var lastBatch = await DocumentSerializer.DeserializeBatchFromRightToLeft(_file);
var lastDoc = lastBatch[lastBatch.Count - 1];
return(new DocIdGenerator(lastDoc.Id));
}
finally
{
_file.Position = initialPos;
}
}
public async Task ProcessAsync_ResourceSuccessCommand_CallsTransportAndReturnsOKHttpResponse()
{
// Arrange
TransportSession
.Setup(t => t.ProcessCommandAsync(It.Is <Command>(c => c.Id == RequestCommand.Id && c.Uri.Equals(RequestCommand.Uri)), CancellationToken))
.ReturnsAsync(ResourceSuccessResponseCommand)
.Verifiable();
DocumentSerializer
.Setup(s => s.Serialize(ResourceSuccessResponseCommand.Resource))
.Returns(ResponseContent)
.Verifiable();
// Act
var actual = await Target.ProcessAsync(SendCommandHttpRequest, It.IsAny <UriTemplateMatch>(), TransportSession.Object, CancellationToken);
// Assert
TransportSession.Verify();
DocumentSerializer.Verify();
actual.StatusCode.ShouldBe(HttpStatusCode.OK);
}
private void btnOpen_Click(object sender, EventArgs e)
{
ofd.Filter = "sirius data files (*.sirius)|*.sirius|dxf cad files (*.dxf)|*.dxf|All Files (*.*)|*.*";
ofd.Title = "Open File";
ofd.FileName = string.Empty;
DialogResult result = ofd.ShowDialog(this);
if (result == DialogResult.OK)
{
string ext = Path.GetExtension(ofd.FileName);
if (0 == string.Compare(ext, ".dxf", true))
{
trvEntity.SuspendLayout();
var doc = DocumentSerializer.OpenDxf(ofd.FileName);
trvEntity.ResumeLayout();
if (null == doc)
{
MessageBox.Show($"Fail to open : {ofd.FileName}", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
this.Document = doc;
}
else if (0 == string.Compare(ext, ".sirius", true))
{
trvEntity.SuspendLayout();
var doc = DocumentSerializer.OpenSirius(ofd.FileName);
trvEntity.ResumeLayout();
if (null == doc)
{
MessageBox.Show($"Fail to open : {ofd.FileName}", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
this.Document = doc;
}
else
{
MessageBox.Show($"Unsupported file extension : {ofd.FileName}", "File Type Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
public DocumentDatabase(IndexModel indexModel)
{
var path = $"{AppDomain.CurrentDomain.BaseDirectory}data/{indexModel.DatabaseName}";
FileOperations.CheckOrCreateDirectory(path);
path += $"/{indexModel.IndexName}";
_dbFileStream = new FileStream(path + ".col", FileMode.OpenOrCreate, FileAccess.ReadWrite,
FileShare.None, 4096);
_indexFileStream = new FileStream(path + ".pidx", FileMode.OpenOrCreate, FileAccess.ReadWrite,
FileShare.None, 4096);
_secondaryFileStream = new FileStream(path + ".sidx", FileMode.OpenOrCreate, FileAccess.ReadWrite,
FileShare.None, 4096);
// Construct the RecordStorage that use to store main cow data
_records = new RecordStorage(new BlockStorage(_dbFileStream, 4096));
// Construct the primary and secondary indexes
_index = new Tree <Guid, uint>(
new TreeDiskNodeManager <Guid, uint>(
new GuidSerializer(),
new TreeUIntSerializer(),
new RecordStorage(new BlockStorage(_indexFileStream, 4096))
)
);
_secondaryIndex = new Tree <string, Dictionary <string, Guid> >(
new TreeDiskNodeManager <string, Dictionary <string, Guid> >(
new StringSerializer(),
new DictSerializer(),
new RecordStorage(
new BlockStorage(_secondaryFileStream, 4096)
)
),
true);
_documentSerializer = new DocumentSerializer();
_indexingOperations = new IndexingOperations();
IndexModel = indexModel;
}
// T can be any type that derived from BaseResult and results are not change tracked
// method could be used if we dont want to change track T here
public async Task <ICommandResult <T> > RequestMergedResult <T>(object data = null)
{
DistinctCommandResult <T> result = new DistinctCommandResult <T>();
var response = await SendCommandAsync(data).ConfigureAwait(false);
using (var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
{
var serializer = new DocumentSerializer(db);
result.Result = serializer.Deserialize <T>(stream);
result.BaseResult = result.Result as BaseResult;
if (!response.IsSuccessStatusCode)
{
result.Result = default(T);
}
}
new BaseResultAnalyzer(db).ThrowIfNeeded(result.BaseResult);
return(result);
}
private void AssertToStringEquals(string expected, MdDocument document, MdSerializationOptions?options = null)
{
using (var writer = new StringWriter())
{
var serializer = new DocumentSerializer(writer, options);
serializer.Serialize(document);
var actual = writer.ToString();
m_OutputHelper.WriteLine("--------------");
m_OutputHelper.WriteLine("Expected:");
m_OutputHelper.WriteLine("--------------");
m_OutputHelper.WriteLine(expected);
m_OutputHelper.WriteLine("--------------");
m_OutputHelper.WriteLine("Actual:");
m_OutputHelper.WriteLine("--------------");
m_OutputHelper.WriteLine(actual);
m_OutputHelper.WriteLine("--------------");
Assert.Equal(expected, actual);
}
}
public async Task <List <Document> > GetChunk(long offset)
{
var compression = new CompressionUtils();
if (offset >= _file.Length)
{
// should NEVER happen
throw new InvalidOperationException("Specified position doesn't exist in data file");
}
using (var file = new FileStream(_filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
var segment = await compression.ReadWithDecompression(file, offset);
using (var ms = new MemoryStream(segment.Array, segment.Offset, segment.Count))
{
var batch = await DocumentSerializer.DeserializeBatch(ms).ConfigureAwait(false);
return(batch);
}
}
}
public T Deserialize <T>(string json)
{
if (string.IsNullOrEmpty(json))
{
return(default(T));
}
var type = typeof(T);
object document = null;
using (var reader = new StringReader(json))
document = DocumentSerializer.Deserialize(reader, type);
using (var reader = new StringReader(json))
if (!type.IsInstanceOfType(typeof(BaseDocument)))
{
var key = KeyAccessor.GetId(document, type);
var metadata = (DocumentMetadata)MetadataSerialzier.Deserialize(reader, typeof(DocumentMetadata));
MetadataProvider.SetMetadata(key, metadata);
}
return((T)document);
}
private static bool DrawByMarker(IRtc rtc, ILaser laser, IMarker marker, IMotor motor)
{
#region load from sirius file
var dlg = new OpenFileDialog();
dlg.Filter = "sirius data files (*.sirius)|*.sirius|dxf cad files (*.dxf)|*.dxf|All Files (*.*)|*.*";
dlg.Title = "Open to data file";
DialogResult result = dlg.ShowDialog();
if (result != DialogResult.OK)
{
return(false);
}
string ext = Path.GetExtension(dlg.FileName);
IDocument doc = null;
if (0 == string.Compare(ext, ".dxf", true))
{
doc = DocumentSerializer.OpenDxf(dlg.FileName);
}
else if (0 == string.Compare(ext, ".sirius", true))
{
doc = DocumentSerializer.OpenSirius(dlg.FileName);
}
#endregion
Debug.Assert(null != doc);
// 마커 가공 준비
marker.Ready(new MarkerArgDefault()
{
Document = doc,
Rtc = rtc,
Laser = laser,
MotorZ = motor,
});
// 하나의 오프셋 정보 추가
marker.MarkerArg.Offsets.Clear();
marker.MarkerArg.Offsets.Add(Offset.Zero);
// 가공 시작
return(marker.Start());
}
public async Task CommitTran(Tran tran)
{
await _commitLock.WaitAsync().ConfigureAwait(false);
try
{
using (Measured.Operation("wal_commit"))
{
foreach (var doc in tran.Documents)
{
doc.Id = _docIdGenerator.GetNextId();
}
await DocumentSerializer.SerializeBatch(tran.Documents, _file).ConfigureAwait(false);
await _file.FlushAsync().ConfigureAwait(false);
}
}
finally
{
_commitLock.Release();
}
}
private async Task <DataFileCommitInfo> Commit()
{
var compression = new CompressionUtils();
var commitInfo = new DataFileCommitInfo();
while (_nonPersistedQ.Count >= _batchSize)
{
var batchStartPos = _file.Position;
var nextBatch = ReadNextBatchFromQueue();
using (var ms = new MemoryStream())
{
await DocumentSerializer.SerializeBatch(nextBatch, ms).ConfigureAwait(false);
await compression.CopyWithCompression(ms, _file).ConfigureAwait(false);
await _file.FlushAsync().ConfigureAwait(false);
}
commitInfo.RecordCommittedBatch(batchStartPos, nextBatch);
}
return(commitInfo);
}
public void Execute()
{
var deleteSet = new HashSet <ulong>(
_pks.Select(x => x.ToHash()).ToList());
foreach (var ix in _ixs)
{
var dataFile = Path.Combine(_directory, ix.Key + ".rdb");
using (var stream = new FileStream(dataFile, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
{
stream.Seek(ix.Value.DocHashOffset, SeekOrigin.Begin);
var buffer = new byte[DocumentSerializer.SizeOfDocHash()];
while (stream.Position < ix.Value.DocAddressesOffset)
{
stream.Read(buffer, 0, buffer.Length);
var hash = DocumentSerializer.DeserializeDocHash(buffer);
if (deleteSet.Contains(hash.Hash))
{
stream.Position = stream.Position - buffer.Length;
buffer[0] = 1;
stream.Write(buffer, 0, buffer.Length);
deleteSet.Remove(hash.Hash);
}
if (deleteSet.Count == 0)
{
break;
}
}
}
}
}
public async Task <List <ICommandResult <T> > > RequestMultipleMergedResult <T>(object data = null)
{
var results = new List <ICommandResult <T> >();
var response = await SendCommandAsync(data).ConfigureAwait(false);
using (var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
{
var serializer = new DocumentSerializer(db);
var _results = serializer.Deserialize <List <T> >(stream);
foreach (var r in _results)
{
var distinctResult = new DistinctCommandResult <T>
{
Result = r,
BaseResult = r as BaseResult
};
results.Add(distinctResult);
}
}
return(results);
}
public async Task <AnalysisDocument> AnalyseAsync(AnalysisRequest request, CancellationToken cancellationToken)
{
var msg = new AnalysisMessage
{
Spec = SpecUtils.Zip(request.Spec),
PackagesToAnalyze = request.PackagesToAnalyze,
OutputFile = Path.GetTempFileName(),
UsedTypesOnly = request.UsedTypesOnly,
AllEdges = request.AllEdges,
CreateClustersForNamespaces = request.CreateClustersForNamespaces
};
if (request.Spec.Length * 2 > 4000000)
{
throw new NotSupportedException("Spec is too big");
}
var response = await this.ProcessAsync(typeof(PackageAnalysisActor), msg, cancellationToken);
try
{
if (response is AnalysisResponse m)
{
var serializer = new DocumentSerializer();
return(serializer.Deserialize <AnalysisDocument>(m.File));
}
else
{
return(null);
}
}
finally
{
File.Delete(msg.OutputFile);
}
}
static void Main(string[] args)
{
SpiralLab.Core.Initialize();
#region initialize RTC
//var rtc = new RtcVirtual(0); //create Rtc for dummy
var rtc = new Rtc5(0); //create Rtc5 controller
//var rtc = new Rtc6(0); //create Rtc6 controller
//var rtc = new Rtc6Ethernet(0, "192.168.0.100", "255.255.255.0"); //실험적인 상태 (Scanlab Rtc6 Ethernet 제어기)
//var rtc = new Rtc6SyncAxis(0, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "syncAxis", "syncAXISConfig.xml")); //실험적인 상태 (Scanlab XLSCAN 솔류션)
float fov = 60.0f; // scanner field of view : 60mm
float kfactor = (float)Math.Pow(2, 20) / fov; // k factor (bits/mm) = 2^20 / fov
var correctionFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "correction", "cor_1to1.ct5");
rtc.Initialize(kfactor, LaserMode.Yag1, correctionFile); //default correction file
rtc.CtlFrequency(50 * 1000, 2); //laser frequency : 50KHz, pulse width : 2usec
rtc.CtlSpeed(100, 100); // default jump and mark speed : 100mm/s
rtc.CtlDelay(10, 100, 200, 200, 0); //scanner and laser delays
#endregion
#region initialize Laser (virtual)
var laser = new LaserVirtual(0, "virtual", 20); // virtual laser source with max 20W power (최대 출력 20W 의 가상 레이저 소스 생성)
//var laser = new IPGYLP(0, "IPG YLP", 1, 20);
//var laser = new JPTTypeE(0, "JPT Type E", 1, 20);
//var laser = new SPIG4(0, "SPI G3/4", 1, 20);
//var laser = new PhotonicsIndustryDX(0, "PI", 1, 20);
//var laser = new AdvancedOptoWaveFotia(0, "Fotia", 1, 20);
//var laser = new CoherentAviaLX(0, "Avia LX", 1, 20);
laser.Rtc = rtc;
laser.Initialize();
laser.CtlPower(2);
#endregion
#region create entities
// 문서 생성
var doc = new DocumentDefault("Unnamed");
// 레이어 생성및 문서에 추가
var layer = new Layer("default");
// 펜 개체(Entity) 생성및 레이어에 추가
var pen = new PenDefault()
{
Frequency = 100 * 1000, //주파수 Hz
PulseWidth = 2, //펄스폭 usec
LaserOnDelay = 0, // 레이저 시작 지연 usec
LaserOffDelay = 0, // 레이저 끝 지연 usec
ScannerJumpDelay = 100, // 스캐너 점프 지연 usec
ScannerMarkDelay = 200, // 스캐너 마크 지연 usec
ScannerPolygonDelay = 0, // 스캐너 폴리곤 지연 usec
JumpSpeed = 500, // 스캐너 점프 속도 mm/s
MarkSpeed = 500, // 스캐너 마크 속도 mm/s
};
layer.Add(pen);
// 선 개체 레이어에 추가
layer.Add(new Line(0, 0, 10, 20));
// 원 개체 레이어에 추가
layer.Add(new Circle(0, 0, 10));
// 나선 개체 레이어에 추가
layer.Add(new Spiral(-20.0f, 0.0f, 0.5f, 2.0f, 5, true));
//레이어의 모든 개채들 내부 데이타 계산및 갱신
layer.Regen();
// 문서에 레이어 추가
doc.Layers.Add(layer);
// 문서를 지정된 파일에 저장
DocumentSerializer.Save(doc, "test.sirius");
#endregion
ConsoleKeyInfo key;
do
{
Console.WriteLine($"{Environment.NewLine}");
Console.WriteLine("Testcase for spirallab.sirius. powered by [email protected] (http://spirallab.co.kr)");
Console.WriteLine($"{Environment.NewLine}");
Console.WriteLine("'D' : draw entities by pen");
Console.WriteLine("'Q' : quit");
Console.WriteLine($"{Environment.NewLine}");
Console.Write("select your target : ");
key = Console.ReadKey(false);
if (key.Key == ConsoleKey.Q)
{
break;
}
Console.WriteLine($"{Environment.NewLine}");
switch (key.Key)
{
case ConsoleKey.D:
Console.WriteLine("WARNING !!! LASER IS BUSY ...");
var timer = Stopwatch.StartNew();
DrawForFieldCorrection(laser, rtc, doc);
Console.WriteLine($"processing time = {timer.ElapsedMilliseconds / 1000.0:F3}s");
break;
}
} while (true);
rtc.Dispose();
}
public SendRawMessageActionTests()
{
Sender = Substitute.For <ISender>();
DocumentSerializer = new DocumentSerializer();
}
static void Main(string[] args)
{
SpiralLab.Core.Initialize();
#region initialize RTC
IRtc rtc = new RtcVirtual(0); ///가상 rtc 제어기 생성
//IRtc rtc = new Rtc5(0); ///rtc 5 제어기 생성
double fov = 60.0; /// scanner field of view : 60mm
double kfactor = Math.Pow(2, 20) / fov; /// k factor (bits/mm) = 2^20 / fov
rtc.Initialize(kfactor, LaserMode.Yag1, "cor_1to1.ct5"); ///default correction file
rtc.CtlFrequency(50 * 1000, 2); ///laser frequency : 50KHz, pulse width : 2usec
rtc.CtlSpeed(100, 100); /// default jump and mark speed : 100mm/s
rtc.CtlDelay(10, 100, 200, 200, 0); ///scanner and laser delays
#endregion
#region initialize Laser(Virtual)
ILaser laser = new LaserVirtual(0, "virtual", 20);
#endregion
#region create entities for scanner field correction
var doc = new DocumentDefault("3x3 scanner field correction");
var layer = new Layer("default");
doc.Layers.Add(layer);
/// 9 (3x3) 측정 위치에 마킹할 형상 생성 (나선 모양의 객체)
layer.Add(new Spiral(-20.0f, 20.0f, 0.2f, 2.0f, 5, true));
layer.Add(new Spiral(0.0f, 20.0f, 0.2f, 2.0f, 5, true));
layer.Add(new Spiral(20.0f, 20.0f, 0.2f, 2.0f, 5, true));
layer.Add(new Spiral(-20.0f, 0.0f, 0.2f, 2.0f, 5, true));
layer.Add(new Spiral(0.0f, 0.0f, 0.2f, 2.0f, 5, true));
layer.Add(new Spiral(20.0f, 0.0f, 0.2f, 2.0f, 5, true));
layer.Add(new Spiral(-20.0f, -20.0f, 0.2f, 2.0f, 5, true));
layer.Add(new Spiral(0.0f, -20.0f, 0.2f, 2.0f, 5, true));
layer.Add(new Spiral(20.0f, -20.0f, 0.2f, 2.0f, 5, true));
var ds = new DocumentSerializer();
ds.Save(doc, "test.sirius");
#endregion
ConsoleKeyInfo key;
do
{
Console.WriteLine("Testcase for spirallab.sirius. powered by [email protected] (https://sepwind.blogspot.com)");
Console.WriteLine("");
Console.WriteLine("'F' : draw field correction entities");
Console.WriteLine("'C' : create new field correction for 2D");
Console.WriteLine("'Q' : quit");
Console.WriteLine("");
Console.Write("select your target : ");
key = Console.ReadKey(false);
if (key.Key == ConsoleKey.Q)
{
break;
}
switch (key.Key)
{
case ConsoleKey.F:
Console.WriteLine("\r\nWARNING !!! LASER IS BUSY ...");
var timer = new Stopwatch();
if (DrawForFieldCorrection(laser, rtc, doc))
{
rtc.ListExecute(true);
}
Console.WriteLine($"processing time = {timer.ElapsedMilliseconds / 1000.0:F3}s");
break;
case ConsoleKey.C:
string result = CreateFieldCorrection();
Console.WriteLine("");
Console.WriteLine(result);
break;
}
} while (true);
rtc.Dispose();
}
public void Setup()
{
Serializer = new DocumentSerializer();
DocumentModel = Data.SetData(new IndexModel("bin", "stor")).First();
}
public SendRawMessageActionTests()
{
Sender = Substitute.For <ISender>();
DocumentTypeResolver = new DocumentTypeResolver().WithBlipDocuments();
DocumentSerializer = new DocumentSerializer(DocumentTypeResolver);
}
static void Main(string[] args)
{
SpiralLab.Core.Initialize();
#region initialize RTC
IRtc rtc = new RtcVirtual(0); ///가상 rtc 제어기 생성
//IRtc rtc = new Rtc5(0); ///rtc 5 제어기 생성
double fov = 60.0; /// scanner field of view : 60mm
double kfactor = Math.Pow(2, 20) / fov; /// k factor (bits/mm) = 2^20 / fov
rtc.Initialize(kfactor, LaserMode.Yag1, "cor_1to1.ct5"); ///default correction file
rtc.CtlFrequency(50 * 1000, 2); ///laser frequency : 50KHz, pulse width : 2usec
rtc.CtlSpeed(100, 100); /// default jump and mark speed : 100mm/s
rtc.CtlDelay(10, 100, 200, 200, 0); ///scanner and laser delays
#endregion
#region initialize Laser (virtial)
ILaser laser = new LaserVirtual(0, "virtual", 20);
#endregion
#region create entities
var doc = new DocumentDefault("Unnamed");
var layer = new Layer("default");
doc.Layers.Add(layer);
///첫번째 그룹 객체 생성
var group1 = new Group();
group1.Add(
new Pen()
{
Frequency = 100 * 1000,
PulseWidth = 2,
LaserOnDelay = 0,
LaserOffDelay = 0,
ScannerJumpDelay = 100,
ScannerMarkDelay = 200,
ScannerPolygonDelay = 0,
JumpSpeed = 500,
MarkSpeed = 500,
}
);
group1.Add(new Line(0, 0, 10, 20));
group1.Add(new Circle(0, 0, 10));
group1.Add(new Spiral(-20.0f, 0.0f, 0.5f, 2.0f, 5, true));
group1.RepeatCount = 10; /// 10회 가공
/// 두번째 그룹 객체 생성
var group2 = new Group();
group2.Add(
new Pen()
{
Frequency = 50 * 1000,
PulseWidth = 2,
LaserOnDelay = 0,
LaserOffDelay = 0,
ScannerJumpDelay = 100,
ScannerMarkDelay = 200,
ScannerPolygonDelay = 0,
JumpSpeed = 100,
MarkSpeed = 100,
}
);
group1.Add(new Line(0, 0, 5, 10));
group1.Add(new Circle(0, 0, 50));
group1.Add(new Spiral(-10.0f, 0.0f, 0.5f, 2.0f, 10, true));
group1.RepeatCount = 20; /// 20 회 가공
layer.Add(group2);
var ds = new DocumentSerializer();
ds.Save(doc, "test.sirius");
#endregion
ConsoleKeyInfo key;
do
{
Console.WriteLine("Testcase for spirallab.sirius. powered by [email protected](https://sepwind.blogspot.com)");
Console.WriteLine("");
Console.WriteLine("'D' : draw group entities with pen");
Console.WriteLine("'Q' : quit");
Console.WriteLine("");
Console.Write("select your target : ");
key = Console.ReadKey(false);
if (key.Key == ConsoleKey.Q)
{
break;
}
switch (key.Key)
{
case ConsoleKey.D:
Console.WriteLine("\r\nWARNING !!! LASER IS BUSY ...");
var timer = new Stopwatch();
if (DrawForFieldCorrection(laser, rtc, doc))
{
rtc.ListExecute(true);
Console.WriteLine($"processing time = {timer.ElapsedMilliseconds / 1000.0:F3}s");
}
break;
}
} while (true);
rtc.Dispose();
}
protected virtual IDictionary <string, string> GenerateJsonCompatibleKeyValues(SearchIndexRequest request)
{
var kvs = new Dictionary <string, string>();
if (!string.IsNullOrWhiteSpace(request.Expression))
{
kvs.Add(KeyNames.Expression, request.Expression);
}
if (request.HasSortings())
{
kvs.Add(KeyNames.Sort, DocumentSerializer.ToJsonArray(request.Sort.ToArray()));
}
if (!string.IsNullOrWhiteSpace(request.Bookmark))
{
kvs.Add(KeyNames.Bookmark, request.Bookmark);
}
if (request.Stale.HasValue)
{
kvs.Add(KeyNames.Stale, request.Stale.Value.AsString());
}
if (request.Limit.HasValue)
{
kvs.Add(KeyNames.Limit, DocumentSerializer.ToJson(request.Limit.Value));
}
if (request.IncludeDocs.HasValue)
{
kvs.Add(KeyNames.IncludeDocs, DocumentSerializer.ToJson(request.IncludeDocs.Value));
}
if (request.Ranges != null)
{
kvs.Add(KeyNames.Ranges, Serializer.Serialize(request.Ranges));
}
if (request.HasCounts())
{
kvs.Add(KeyNames.Counts, DocumentSerializer.ToJsonArray(request.Counts.ToArray()));
}
if (!string.IsNullOrWhiteSpace(request.GroupField))
{
kvs.Add(KeyNames.GroupField, request.GroupField);
}
if (request.GroupLimit.HasValue)
{
kvs.Add(KeyNames.GroupLimit, DocumentSerializer.ToJson(request.GroupLimit.Value));
}
if (request.HasGroupSortings())
{
kvs.Add(KeyNames.GroupSort, DocumentSerializer.ToJsonArray(request.GroupSort.ToArray()));
}
if (request.DrillDown.HasValue)
{
kvs.Add(KeyNames.DrillDown, DocumentSerializer.ToJsonArray(new [] { request.DrillDown.Value.Key, request.DrillDown.Value.Value }));
}
return(kvs);
}
public VariableService(DocumentSerializer serializer, IEnumerable <IVariableProvider> variableProviders)
{
_serializer = serializer;
_variableProviders = variableProviders;
}
public DocumentSerializerTests()
{
SUT = new DocumentSerializer(new SerializationConfiguration(), new DocumentSerializationMetaProvider());
}
public async Task <IEnumerable <KeyValuePair <string, Document> > > GetAllDocumentsAsync(DocumentCollection keysCollection, BucketNamespace bucketNamespace)
{
if (keysCollection.Total == 0)
{
return(null);
}
try
{
string @namespace;
switch (bucketNamespace)
{
case BucketNamespace.Document:
@namespace = "buckets";
break;
case BucketNamespace.Resource:
@namespace = "resources";
break;
case BucketNamespace.Profile:
@namespace = "profile";
break;
default:
@namespace = "buckets";
break;
}
var pairsCollection = new List <KeyValuePair <string, Document> >();
foreach (var key in keysCollection.Items)
{
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri($"/{@namespace}/{key}"),
Method = CommandMethod.Get
};
var documentSerializer = new DocumentSerializer();
var envelopeSerializer = new JsonNetSerializer();
var commandString = envelopeSerializer.Serialize(command);
var httpContent = new StringContent(commandString, Encoding.UTF8, "application/json");
HttpResponseMessage response = await _client.PostAsync("/commands", httpContent);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
var envelopeResult = (Command)envelopeSerializer.Deserialize(responseBody);
var document = envelopeResult.Resource;
pairsCollection.Add(new KeyValuePair <string, Document>(key.ToString(), document));
}
return(pairsCollection);
}
catch (HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
return(null);
}
}
static void Main(string[] args)
{
SpiralLab.Core.Initialize();
#region create entities
//신규 문서(Document) 생성
var doc1 = new DocumentDefault("Unnamed");
// 레이어 생성
var layer = new Layer("default");
//레이어에 선 형상 개체(Entity) 생성및 추가
layer.Add(new Line(0, 10, 20, 20));
//레이어에 원 형상 개체(Entity) 생성및 추가
layer.Add(new Circle(0, 0, 10));
//레이어에 나선 형상 개체(Entity) 생성및 추가
layer.Add(new Spiral(-20.0f, 0.0f, 0.5f, 2.0f, 5, true));
// 레이어를 문서에 추가
doc1.Layers.Add(layer);
#endregion
Console.WriteLine("press any key to save ...");
Console.ReadKey(false);
string filename = "default.sirius";
// 문서(Document) 저장하기
DocumentSerializer.Save(doc1, filename);
Console.WriteLine("press any key to open ...");
Console.ReadKey(false);
// 문서(Document) 불러오기
var doc2 = DocumentSerializer.OpenSirius(filename);
Console.WriteLine("press any key to rtc initialize ...");
Console.ReadKey(false);
#region initialize RTC
//var rtc = new RtcVirtual(0); //create Rtc for dummy
var rtc = new Rtc5(0, "output.txt"); //create Rtc5 controller with list commands output file
//var rtc = new Rtc6(0); //create Rtc6 controller
//var rtc = new Rtc6Ethernet(0, "192.168.0.100", "255.255.255.0"); //실험적인 상태 (Scanlab Rtc6 Ethernet 제어기)
//var rtc = new Rtc6SyncAxis(0, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "syncAxis", "syncAXISConfig.xml")); //실험적인 상태 (Scanlab XLSCAN 솔류션)
float fov = 60.0f; // scanner field of view : 60mm
float kfactor = (float)Math.Pow(2, 20) / fov; // k factor (bits/mm) = 2^20 / fov
var correctionFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "correction", "cor_1to1.ct5");
rtc.Initialize(kfactor, LaserMode.Yag1, correctionFile); // 스캐너 보정 파일 지정 : correction file
rtc.CtlFrequency(50 * 1000, 2); // laser frequency : 50KHz, pulse width : 2usec
rtc.CtlSpeed(100, 100); // default jump and mark speed : 100mm/s
rtc.CtlDelay(10, 100, 200, 200, 0); // scanner and laser delays
#endregion
#region initialize Laser (virtual)
var laser = new LaserVirtual(0, "virtual", 20); // virtual laser source with max 20W power (최대 출력 20W 의 가상 레이저 소스 생성)
//var laser = new IPGYLP(0, "IPG YLP", 1, 20);
//var laser = new JPTTypeE(0, "JPT Type E", 1, 20);
//var laser = new SPIG4(0, "SPI G3/4", 1, 20);
//var laser = new PhotonicsIndustryDX(0, "PI", 1, 20);
//var laser = new AdvancedOptoWaveFotia(0, "Fotia", 1, 20);
//var laser = new CoherentAviaLX(0, "Avia LX", 1, 20);
laser.Rtc = rtc;
laser.Initialize();
laser.CtlPower(2);
#endregion
Console.WriteLine("press any key to laser processing ...WARNING !!! LASER EMISSION");
Console.ReadKey(false);
DoBegin(laser, rtc, doc2);
Console.WriteLine("press any key to terminate program");
Console.ReadKey(false);
}
static void Main(string[] args)
{
SpiralLab.Core.Initialize();
#region initialize RTC
//var rtc = new RtcVirtual(0); //create Rtc for dummy
var rtc = new Rtc5(0); //create Rtc5 controller
//var rtc = new Rtc6(0); //create Rtc6 controller
//var rtc = new Rtc6Ethernet(0, "192.168.0.100", "255.255.255.0"); //실험적인 상태 (Scanlab Rtc6 Ethernet 제어기)
//var rtc = new Rtc6SyncAxis(0, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "syncAxis", "syncAXISConfig.xml")); //실험적인 상태 (Scanlab XLSCAN 솔류션)
float fov = 60.0f; // scanner field of view : 60mm
float kfactor = (float)Math.Pow(2, 20) / fov; // k factor (bits/mm) = 2^20 / fov
var correctionFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "correction", "cor_1to1.ct5");
rtc.Initialize(kfactor, LaserMode.Yag1, correctionFile); //default correction file
rtc.CtlFrequency(50 * 1000, 2); //laser frequency : 50KHz, pulse width : 2usec
rtc.CtlSpeed(100, 100); // default jump and mark speed : 100mm/s
rtc.CtlDelay(10, 100, 200, 200, 0); //scanner and laser delays
#endregion
#region initialize Laser (virtual)
var laser = new LaserVirtual(0, "virtual", 20); // virtual laser source with max 20W power (최대 출력 20W 의 가상 레이저 소스 생성)
//var laser = new IPGYLP(0, "IPG YLP", 1, 20);
//var laser = new JPTTypeE(0, "JPT Type E", 1, 20);
//var laser = new SPIG4(0, "SPI G3/4", 1, 20);
//var laser = new PhotonicsIndustryDX(0, "PI", 1, 20);
//var laser = new AdvancedOptoWaveFotia(0, "Fotia", 1, 20);
//var laser = new CoherentAviaLX(0, "Avia LX", 1, 20);
laser.Rtc = rtc;
laser.Initialize();
laser.CtlPower(2);
#endregion
#region create entity at 0,0 location
var doc = new DocumentDefault("3x3 scanner field correction");
// 레이어 생성
var layer = new Layer("default");
// 나선 개체 추가
layer.Add(new Spiral(0.0f, 0.0f, 0.5f, 2.0f, 5, true));
// 레이어의 모든 개채들 내부 데이타 계산및 갱신
layer.Regen();
// 문서에 레이어 추가
doc.Layers.Add(layer);
// 문서 저장
DocumentSerializer.Save(doc, "test.sirius");
#endregion
ConsoleKeyInfo key;
do
{
Console.WriteLine($"{Environment.NewLine}");
Console.WriteLine("Testcase for spirallab.sirius. powered by [email protected] (http://spirallab.co.kr)");
Console.WriteLine($"{Environment.NewLine}");
Console.WriteLine("'M' : draw entities by marker");
Console.WriteLine("'O' : draw entities by marker with offsets");
Console.WriteLine("'Q' : quit");
Console.WriteLine($"{Environment.NewLine}");
Console.Write("select your target : ");
key = Console.ReadKey(false);
if (key.Key == ConsoleKey.Q)
{
break;
}
Console.WriteLine($"{Environment.NewLine}");
switch (key.Key)
{
case ConsoleKey.M:
Console.WriteLine("WARNING !!! LASER IS BUSY ...");
DrawByMarker(doc, rtc, laser);
break;
case ConsoleKey.O:
Console.WriteLine("WARNING !!! LASER IS BUSY ...");
DrawByMarkerWithOffset(doc, rtc, laser);
break;
}
} while (true);
rtc.Dispose();
}
/// <summary>
/// Imports documents
/// </summary>
/// <param name="collection">The collection name</param>
/// <param name="documents">Documents to import</param>
/// <param name="createCollection">If true, then the collection is created if it does not yet exist</param>
/// <param name="overwrite">If true, then all data in the collection will be removed prior to the import</param>
/// <param name="waitForSync">Wait until document has been synced to disk</param>
/// <param name="onDuplicate">Controls what action is carried out in case of a unique key constraint violation</param>
/// <param name="complete">If true, then it will make the whole import fail if any error occurs</param>
/// <param name="details">If true, then the result will include details about documents that could not be imported</param>
/// <param name="baseResult"></param>
/// <returns>BulkImportResult</returns>
public async Task <BulkImportResult> BulkImportAsync(string collection, IEnumerable documents, bool?createCollection = null, bool?overwrite = null
, bool?waitForSync = null, ImportDuplicatePolicy?onDuplicate = null, bool?complete = null, bool?details = null
, Action <BaseResult> baseResult = null)
{
createCollection = createCollection ?? db.Setting.CreateCollectionOnTheFly;
waitForSync = waitForSync ?? db.Setting.WaitForSync;
var command = new HttpCommand(db)
{
Api = CommandApi.Import,
Method = HttpMethod.Post,
Query = new Dictionary <string, string>()
};
command.Query.Add("type", "documents");
command.Query.Add("collection", collection);
command.Query.Add("createCollection", createCollection.ToString());
command.Query.Add("waitForSync", waitForSync.ToString());
if (overwrite.HasValue)
{
command.Query.Add("overwrite", overwrite.ToString());
}
if (onDuplicate.HasValue)
{
command.Query.Add("onDuplicate", Utility.Utils.ImportDuplicatePolicyToString(onDuplicate.Value));
}
if (complete.HasValue)
{
command.Query.Add("complete", complete.ToString());
}
if (details.HasValue)
{
command.Query.Add("details", details.ToString());
}
Func <StreamWriter, Task> onStreamReady = async(streamWriter) =>
{
var docSerializer = new DocumentSerializer(db);
var serializer = docSerializer.CreateJsonSerializer();
var jsonWriter = new JsonTextWriter(streamWriter);
foreach (var d in documents)
{
string json = d as string;
if (json != null)
{
streamWriter.Write($"{json}{Environment.NewLine}");
continue;
}
var jObject = d as JObject;
if (jObject != null)
{
jObject.WriteTo(jsonWriter);
streamWriter.Write(Environment.NewLine);
continue;
}
serializer.Serialize(jsonWriter, d);
streamWriter.Write(Environment.NewLine);
}
await streamWriter.FlushAsync().ConfigureAwait(false);
};
var result = await command.RequestDistinctResult <BulkImportResult>(onStreamReady : onStreamReady).ConfigureAwait(false);
baseResult?.Invoke(result.BaseResult);
return(result.Result);
}
