private const string RosMaster = "127.0.0.1"; // replace with your ROS machine
public static void Main(string[] args)
{
using (var pipeline = Pipeline.Create())
{
var turtle = new TurtleComponent(pipeline, new Turtle(RosSlave, RosMaster));
turtle.PoseChanged.Do(p => Console.WriteLine($"x={p.Item1} y={p.Item2} theta={p.Item3}"));
var keys = Generators.Sequence(pipeline, Keys(), TimeSpan.FromMilliseconds(10));
keys.Select(k =>
{
if (k == ConsoleKey.Q)
{
turtle.Stop();
}
var linear = k == ConsoleKey.UpArrow ? 1f : k == ConsoleKey.DownArrow ? -1f : 0f;
var angular = k == ConsoleKey.LeftArrow ? 1f : k == ConsoleKey.RightArrow ? -1f : 0f;
return(Tuple.Create(linear, angular));
}).PipeTo(turtle.Velocity);
pipeline.Run();
}
}
public PassportMap()
{
Id(x => x.Id, m =>
{
m.Generator(Generators.Foreign <Passport>(x => x.Doctor));
});
Property(x => x.HashAndSalt, m =>
{
m.Length(PasswordHash.PasswordHashManager.HASH_LENGTH);
});
Property(x => x.Remember, m =>
{
m.Column(c =>
{
c.Default(0);
});
m.NotNullable(true);
});
OneToOne(x => x.Doctor, m => { });
}
public void Enumerables()
{
try
{
using (var p = Pipeline.Create())
{
var store = PsiStore.Create(p, "Store", null);
Generators.Return(p, new double[] { 1, 2, 3 }).Select(l => l.Select(d => d + 1)).Write("Test", store);
p.Run();
}
}
catch (AggregateException ex)
{
Assert.AreEqual(1, ex.InnerExceptions.Count);
Assert.IsTrue(ex.InnerExceptions[0].GetType() == typeof(NotSupportedException));
Assert.IsTrue(ex.InnerExceptions[0].Message.StartsWith("Cannot clone Func"));
return;
}
Assert.Fail("Should have thrown above");
}
public RootPerson()
{
gender = Generators.RootGender();
ageGroup = Generators.RootAgeGroup();
age = Generators.Age(ageGroup);
sexuality = Generators.RootSexuality(gender);
wealth = Generators.RootWealth(ageGroup);
if (sexuality == Sexuality.aroAce)
{
relationship = Relationship.single;
}
else
{
relationship = Generators.RootRelationship(wealth, ageGroup);
}
skinColor = Generators.RootSkinColor();
hairColor = Generators.RootHairColor(skinColor);
eyeColor = Generators.RootEyeColor(skinColor);
}
public CPictureMap()
{
Table("CPicture");
Lazy(false);
DynamicInsert(true);
DynamicUpdate(true);
//! NOTE: one-to-one 의 연결 고리가 이상하다!!!
Id(x => x.Id, c => {
c.Column("EmployeeId");
c.Generator(Generators.Foreign <CPicture>(x => x.Employee));
});
Property(x => x.Sign, c => c.Length(1024));
Property(x => x.Stamp, x => x.Length(1024));
OneToOne(x => x.Employee, c => {
c.Cascade(Cascade.Persist);
c.Constrained(true);
});
}
private dynamic InstanceToDynamic <T>(T instance)
{
// Rube Goldberg machine to convert instance to dynamic by
// writing to a store (typed) and reading back as dynamic
using (var p = Pipeline.Create())
{
var gen = Generators.Return(p, instance);
var exporter = PsiStore.Create(p, "Test", this.path);
exporter.Write(gen.Out, "Data", true);
p.Run();
}
using (var p = Pipeline.Create())
{
var importer = PsiStore.Open(p, "Test", this.path);
var data = importer.OpenDynamicStream("Data");
var result = data.ToEnumerable();
p.Run();
return(result.First());
}
}
public void ReceiveClassByRef()
{
var c = new STClass();
STClass result = null;
using (var p = Pipeline.Create("ReceiveClassByRef", DeliveryPolicy.Unlimited, allowSchedulingOnExternalThreads: true))
{
var receiver = p.CreateReceiver<STClass>(
this,
msg =>
{
result = msg.Data;
},
"receiver");
Generators.Return(p, c).PipeTo(receiver, Immediate);
p.Run();
}
Assert.IsTrue(result.Same(c));
Assert.AreEqual(result, c); // we expect the same instance
}
public void ReceiveClassByValue()
{
var c = new STClass();
STClass result = null;
using (var p = Pipeline.Create())
{
var receiver = p.CreateReceiver<STClass>(
this,
msg =>
{
result = msg.Data;
},
"receiver");
Generators.Return(p, c).PipeTo(receiver, DeliveryPolicy.Unlimited);
p.Run();
}
Assert.IsTrue(result.Same(c));
Assert.AreNotEqual(result, c); // we expect a different instance
}
/// <see cref="IGeneratorMode"/>
public override bool Initialize(string path, string[] args)
{
_directory = path;
// Look for the config
var configPath = Path.Combine(_directory, "cgbr.json");
if (!File.Exists(configPath))
{
Console.WriteLine("Project mode requires a config.");
return(false);
}
// Read and parse config
var configText = File.ReadAllText(configPath);
var config = JsonConvert.DeserializeObject <CgbrConfiguration>(configText);
// Load extension parsers
var assemblies = ResolveAssemblies(config.Extensions);
GeneratorFactory.Initialize(assemblies);
// Parser mappings
foreach (var mapping in config.Mappings)
{
Parsers[mapping.Extension] = ParserFactory.Resolve(mapping.Parser);
}
// Generators
foreach (var localGenerator in config.LocalGenerators.Where(gen => gen.IsEnabled))
{
Generators.Add(GeneratorFactory.Resolve(localGenerator.Name));
}
foreach (var globalGenerator in config.GlobalGenerators.Where(gen => gen.IsEnabled))
{
Generators.Add(GeneratorFactory.Resolve(globalGenerator.Name));
}
return(true);
}
public void TupleCollapsingPairWithoutInitialValue()
{
using (var pipeline = Pipeline.Create())
{
var range = Generators.Range(pipeline, 0, 10, TimeSpan.FromMilliseconds(100));
var sourceA = range.Select(x => $"A{x}");
var sourceB = range.Select(x => $"B{x}");
var sourceC = range.Select(x => $"C{x}");
var sourceD = range.Select(x => $"D{x}");
var sourceE = range.Select(x => $"E{x}");
var sourceF = range.Select(x => $"F{x}");
var sourceG = range.Select(x => $"G{x}");
ListObservable <ValueTuple <string, string, string, string, string, string, string> > tuples = // expecting tuple flattening
sourceA
.Pair(sourceB)
.Pair(sourceC)
.Pair(sourceD)
.Pair(sourceE)
.Pair(sourceF)
.Pair(sourceG)
.ToObservable().ToListObservable();
pipeline.Run();
// cannot validate length as above because without initial value, it is non-deterministic
var results = tuples.AsEnumerable().ToArray();
// cannot validate content ordering as with Join because Pair is inherently non-deterministic
foreach (var r in results)
{
Assert.IsTrue(r.Item1.StartsWith("A"));
Assert.IsTrue(r.Item2.StartsWith("B"));
Assert.IsTrue(r.Item3.StartsWith("C"));
Assert.IsTrue(r.Item4.StartsWith("D"));
Assert.IsTrue(r.Item5.StartsWith("E"));
Assert.IsTrue(r.Item6.StartsWith("F"));
Assert.IsTrue(r.Item7.StartsWith("G"));
}
}
}
public void TupleCollapsingReversedJoin()
{
using var pipeline = Pipeline.Create();
var range = Generators.Range(pipeline, 0, 10, TimeSpan.FromMilliseconds(10));
var sourceA = range.Select(x => $"A{x}");
var sourceB = range.Select(x => $"B{x}");
var sourceC = range.Select(x => $"C{x}");
var sourceD = range.Select(x => $"D{x}");
var sourceE = range.Select(x => $"E{x}");
var sourceF = range.Select(x => $"F{x}");
var sourceG = range.Select(x => $"G{x}");
var tuplesFG = sourceF.Join(sourceG);
var tuplesEFG = sourceE.Join(tuplesFG);
var tuplesDEFG = sourceD.Join(tuplesEFG);
var tuplesCDEFG = sourceC.Join(tuplesDEFG);
var tuplesBCDEFG = sourceB.Join(tuplesCDEFG);
var tuplesABCDEFG = sourceA.Join(tuplesBCDEFG);
var tuples = tuplesABCDEFG.ToObservable().ToListObservable();
pipeline.Run();
var results = tuples.AsEnumerable().ToArray();
Assert.IsTrue(Enumerable.SequenceEqual(
new ValueTuple <string, string, string, string, string, string, string>[]
{
ValueTuple.Create("A0", "B0", "C0", "D0", "E0", "F0", "G0"),
ValueTuple.Create("A1", "B1", "C1", "D1", "E1", "F1", "G1"),
ValueTuple.Create("A2", "B2", "C2", "D2", "E2", "F2", "G2"),
ValueTuple.Create("A3", "B3", "C3", "D3", "E3", "F3", "G3"),
ValueTuple.Create("A4", "B4", "C4", "D4", "E4", "F4", "G4"),
ValueTuple.Create("A5", "B5", "C5", "D5", "E5", "F5", "G5"),
ValueTuple.Create("A6", "B6", "C6", "D6", "E6", "F6", "G6"),
ValueTuple.Create("A7", "B7", "C7", "D7", "E7", "F7", "G7"),
ValueTuple.Create("A8", "B8", "C8", "D8", "E8", "F8", "G8"),
ValueTuple.Create("A9", "B9", "C9", "D9", "E9", "F9", "G9"),
},
results));
}
protected virtual void WindDrivenMap()
{
Texture2D newTexture = new Texture2D(textureWidth, textureHeight);
Vector2 center = new Vector2((textureWidth / 2), (textureHeight / 2));
float xOffsetPos = transform.position.x - center.x + fixedOffsetX;
//z here because players move latterally along the x/z plane
float yOffsetPos = transform.position.z - center.y + fixedOffsetY;
Vector2 wind = Generators.GetDirectionalNoise(xOffsetPos, yOffsetPos, maxX, maxY, scale, Time.timeSinceLevelLoad * 0.05f);
wind *= directionStrength;
trackedX += wind.x;
trackedY += wind.y;
xOffsetPos += trackedX;
yOffsetPos += trackedY;
if (outputText != null)
{
outputText.text = "Wind Info: TrackedX,TrackedY = " + trackedX.ToString("#.##") + trackedY.ToString(", #.##");
}
if (samplePointMarker != null)
{
samplePointMarker.transform.position = new Vector3(xOffsetPos, 0, yOffsetPos);
}
Debug.DrawLine(transform.position, transform.position + new Vector3(xOffsetPos, 0.1f, yOffsetPos).normalized, Color.magenta);
for (int x = 0; x < textureWidth; x++)
{
for (int y = 0; y < textureHeight; y++)
{
float output = WeatherSystem.Internal.Generators.GetPerlinNoise(xOffsetPos + x, yOffsetPos + y, maxX, maxY, scale, 0.00f);//Time.timeSinceLevelLoad * 0.05f);
newTexture.SetPixel(x, y, new Color(output, output, output));
}
}
renderer.material.mainTexture = MarkCenter(center, newTexture, Color.green);
newTexture.Apply();
}
/// <summary>
/// Method that generates a store for cross-serialization tests.
/// </summary>
/// <remarks>
/// This method will be invoked in a separate process by the <see cref="CrossFrameworkDeserializeMembers"/>
/// test method to generate a store to test deserialization across different .NET frameworks.
/// </remarks>
public void CrossFrameworkSerializeMembers()
{
using (var p = Pipeline.Create())
{
var testObj = new TypeMembers
{
IntValue = 0x7777AAA,
ByteValue = 0xBB,
BoolValue = true,
ShortValue = 0x7CDD,
LongValue = 0x77777777EEEEEEEE,
CharValue = 'G',
StringValue = "This is a test.",
DoubleValue = Math.PI,
FloatValue = -1.234f,
FloatArray = new[] { 0.1f, 2.3f },
StringList = new List <string> {
"one", "two"
},
StringArraySegment = new ArraySegment <string>(new[] { "aaa", "bbb", "ccc" }, 1, 2),
Queue = new Queue <TimeSpan>(new[] { TimeSpan.Zero, TimeSpan.FromSeconds(1) }),
IntComparer = EqualityComparer <int> .Default,
Tuple = Tuple.Create(0x77777777EEEEEEEE, "This is a tuple."),
ValueTuple = (new DateTime(2020, 1, 2), new Stack <int>(new[] { 33, 782 })),
IntArray = new[] { 0, 3 },
StringArray = new[] { "three", "four" },
EnumComparer = EqualityComparer <DayOfWeek> .Default,
Dictionary = new Dictionary <string, int> {
{ "one", 1 }, { "two", 2 }
},
};
var store = PsiStore.Create(p, "Store2", this.testPath);
Generators.Return(p, testObj).Write("TypeMembers", store);
p.Run();
}
// retain test store for cross-framework tests to run against after this process exits
this.cleanupTestFolder = false;
}
/***************************************************************/
/* Methods returning an InternalEvent as O2DESNet.Event, */
/* with parameters for the objects to be passed in. */
/* Note that the InternalEvent shall always carry This = this. */
/***************************************************************/
//public Event Input(TLoad load) { return new InternalEvent { This = this, Load = load }; }
#endregion
#region Output Events - Reference to Getters
/***********************************************************************/
/* List of functions that maps outgoing objects to an external event. */
/* Note that the mapping is specified only in external structure. */
/***********************************************************************/
//public List<Func<TLoad, Event>> OnOutput { get; private set; } = new List<Func<TLoad, Event>>();
#endregion
public MultiServers(Statics config, int seed, string tag = null) : base(config, seed, tag)
{
int nTypes = Config.HourlyArrivalRates.Length;
int nServers = Config.HourlyServiceRates.GetLength(0);
// 根据每一种类型客户的到达率创建随即发生器
Generators = Enumerable.Range(0, nTypes)
.Select(type => new Generator <Customer>(
new Generator <Customer> .Statics {
Create = rs => new Customer(type),
InterArrivalTime = rs => TimeSpan.FromHours(
Exponential.Sample(rs, Config.HourlyArrivalRates[type])),
SkipFirst = true
}, DefaultRS.Next())).ToArray();
// 创建服务器，并根据不同类型的客户设置服务事件
Servers = Enumerable.Range(0, nServers)
.Select(i => new Server <Customer>(
new Server <Customer> .Statics {
Capacity = Config.Capacities[i],
ServiceTime = (cstm, rs) => TimeSpan.FromHours(
Exponential.Sample(rs, Config.HourlyServiceRates[i, cstm.Config.Type])),
}, DefaultRS.Next())).ToArray();
// 将发生器输出事件连接至内部事件
foreach (var g in Generators)
{
g.OnArrive.Add(c => new ArriveEvent {
This = this, Customer = c
});
}
// 将服务器输出事件连接至内部事件
foreach (var s in Servers)
{
s.OnDepart.Add(c => new DepartEvent {
This = this, Customer = c
});
}
// 初始化事件
InitEvents.AddRange(Generators.Select(g => g.Start()));
}
public void Setup(object data = null)
{
StartCoroutine(FirstUpdatePlanetGeneratorStatesImpl());
planetGeneratorStatesTimer.Setup(0.5f, (delta) => {
if (IsLoaded && Services.GameModeService.IsGame)
{
UpdatePlanetStateGenerators();
}
});
if (false == IsInitialized)
{
Observable.Interval(TimeSpan.FromSeconds(2)).Subscribe(val => {
if (IsLoaded && IsResumed && GameMode.GameModeName == GameModeName.Game)
{
Generators.ClearExpiredBoosts(TimeService.UnixTimeInt);
//UDebug.Log($"clear expired boosts : {val}");
}
}).AddTo(gameObject);
IsInitialized = true;
}
}
/// <summary>
/// Run solution for problem 24.
/// </summary>
/// <remarks>
/// Lexicographic Permutation:
/// A permutation is an ordered arrangement of numbers, letters, or objects. If all of
/// the permutations are listed in particular order it is called lexicographic order.
/// </remarks>
/// <param name="rangeThreshold">Range threshold.</param>
/// <param name="permutationIndex">Lexicographic permutation index.</param>
/// <returns>Lexicographic permutation at <paramref name="permutationIndex"/>.</returns>
public static string Run(int rangeThreshold, int permutationIndex)
{
var numberList = string.Empty;
var permutationCount = 0;
for (var i = 0; i <= rangeThreshold; i += 1)
{
numberList += i;
}
foreach (var permutation in Generators.Permutations(numberList))
{
permutationCount += 1;
if (permutationCount >= permutationIndex)
{
return(permutation);
}
}
throw new IndexOutOfRangeException($"'{numberList}' does not have a {permutationIndex} permutation.");
}
private void LoadGenerators()
{
var json = string.Empty;
var assembly = Assembly.GetExecutingAssembly();
using (var stream = assembly.GetManifestResourceStream("ClickerEngine.Resources.generators.json"))
{
using (var reader = new StreamReader(stream, Encoding.UTF8))
{
json = reader.ReadToEnd();
}
}
dynamic generators = JsonConvert.DeserializeObject(json);
foreach (var generator in generators)
{
string name = generator.Name;
string desc = generator.Description;
string thumbnail = generator.Thumbnail;
Generators.Add(new Generator(name, desc, thumbnail, new Value(1,3)));
}
}
public void SubscriptionAcrossPipelinesShouldThrow()
{
var exceptionThrown = false;
try
{
using (var p = Pipeline.Create())
{
var s = Subpipeline.Create(p, "subpipeline");
var emitter = p.CreateEmitter<int>(this, "pipelineEmitter");
var receiver = s.CreateReceiver<int>(this, x => emitter.Post(x, p.GetCurrentTime()), "subpipelineReceiver");
Generators.Return(p, 123).PipeTo(receiver);
p.Run();
}
}
catch (InvalidOperationException ex)
{
exceptionThrown = true;
Assert.IsTrue(ex.Message.StartsWith("Receiver cannot subscribe to an emitter from a different pipeline"));
}
Assert.IsTrue(exceptionThrown);
}
public void RepeaterPipeline()
{
using (var p = Pipeline.Create("RepeaterPipeline"))
{
// create a generator that will produce a finite sequence
var generator = Generators.Sequence(p, 1, x => x + 1, 100, TimeSpan.FromMilliseconds(1));
var some = generator.Where(x => x % 10 == 0);
var repeat = generator.Pair(some).Item2();
// var output = repeat.Do((x, e) => Console.WriteLine($"{x} [{e.SequenceId}]"));
// var check = repeat.Do((d, e) => Assert.AreEqual(d, e.SequenceId));
var ls = new List <int>();
var collect = repeat.Do(x => ls.Add(x));
// start and run the pipeline
p.Run();
Assert.IsTrue(ls.Sum() > 0);
}
}
public void JoinRepeatPipeline()
{
using (var p = Pipeline.Create("JoinRepeatPipeline"))
{
// create a generator that will produce a finite sequence
var generator = Generators.Sequence(p, 1, x => x + 1, count: 100);
var some = generator.Where(x => x % 10 == 0);
var join = Operators.Join(
generator.Out,
some.Out,
Match.Any <int>(RelativeTimeInterval.RightBounded(TimeSpan.Zero)),
(all, _) => all);
// var output = join.Do(x => Console.WriteLine(x));
var check = join.Do((d, e) => Assert.AreEqual(d, e.SequenceId + 9));
// start and run the pipeline
p.Run();
}
}
public void LatestDelivery()
{
int loopCount = 0;
int lastMsg = 0;
using (var p = Pipeline.Create())
{
var numGen = Generators.Range(p, 10, 3, TimeSpan.FromMilliseconds(100));
numGen.Do(m =>
{
Thread.Sleep(500);
loopCount++;
lastMsg = m;
}, DeliveryPolicy.LatestMessage);
p.RunAsync();
p.WaitAll(700);
}
Assert.AreEqual(2, loopCount);
Assert.AreEqual(12, lastMsg);
}
public static void TestPersonGroup(string subscriptionKey, string endpoint, string groupId, string directory)
{
using var pipeline = Pipeline.Create();
var files = Generators.Sequence(pipeline, Directory.GetFiles(directory), TimeSpan.FromTicks(1));
files
.Select(file => ImagePool.GetOrCreateFromBitmap(new Bitmap(File.OpenRead(file))))
.RecognizeFace(new FaceRecognizerConfiguration(subscriptionKey, endpoint, groupId))
.Join(files)
.Do(x =>
{
Console.WriteLine($"File: {Path.GetFileName(x.Item2)}");
foreach (var candidates in x.Item1)
{
foreach (var(name, confidence) in candidates)
{
Console.WriteLine($" Face: {name} {confidence}");
}
}
});
pipeline.Run();
}
public CatMapping()
{
Table("Cat");
Id(x => x.Id, x =>
{
x.Column(y =>
{
y.Name("CatId");
y.SqlType("char(32)");
y.NotNullable(true);
});
x.Generator(Generators.UUIDHex());
});
Property(x => x.Name, x =>
{
x.Column("Name");
x.Length(16);
x.NotNullable(true);
});
Property(x => x.Sex);
Property(x => x.Weight);
}
public void TupleCollapsingReversedPairWithInitialValue()
{
using (var pipeline = Pipeline.Create())
{
var range = Generators.Range(pipeline, 0, 10, TimeSpan.FromMilliseconds(100));
var sourceA = range.Select(x => $"A{x}");
var sourceB = range.Select(x => $"B{x}");
var sourceC = range.Select(x => $"C{x}");
var sourceD = range.Select(x => $"D{x}");
var sourceE = range.Select(x => $"E{x}");
var sourceF = range.Select(x => $"F{x}");
var sourceG = range.Select(x => $"G{x}");
var tuplesFG = sourceF.Pair(sourceG, "G?");
var tuplesEFG = sourceE.Pair(tuplesFG, ValueTuple.Create("F?", "G?"));
var tuplesDEFG = sourceD.Pair(tuplesEFG, ValueTuple.Create("E?", "F?", "G?"));
var tuplesCDEFG = sourceC.Pair(tuplesDEFG, ValueTuple.Create("D?", "E?", "F?", "G?"));
var tuplesBCDEFG = sourceB.Pair(tuplesCDEFG, ValueTuple.Create("C?", "D?", "E?", "F?", "G?"));
var tuplesABCDEFG = sourceA.Pair(tuplesBCDEFG, ValueTuple.Create("B?", "C?", "D?", "E?", "F?", "G?"));
ListObservable <ValueTuple <string, string, string, string, string, string, string> > tuples = tuplesABCDEFG.ToObservable().ToListObservable();
pipeline.Run();
var results = tuples.AsEnumerable().ToArray();
Assert.AreEqual(10, results.Length);
// can't really validate content ordering as with Join because Pair is inherently non-deterministic
foreach (var r in results)
{
Assert.IsTrue(r.Item1.StartsWith("A"));
Assert.IsTrue(r.Item2.StartsWith("B"));
Assert.IsTrue(r.Item3.StartsWith("C"));
Assert.IsTrue(r.Item4.StartsWith("D"));
Assert.IsTrue(r.Item5.StartsWith("E"));
Assert.IsTrue(r.Item6.StartsWith("F"));
Assert.IsTrue(r.Item7.StartsWith("G"));
}
}
}
public void PostAcrossAsyncComponentsShouldThrow()
{
var exceptionThrown = false;
try
{
using (var p = Pipeline.Create())
{
var componentA = new object();
var componentB = new object();
var emitter = p.CreateEmitter <int>(componentB, "emitterOnB");
var receiver = p.CreateAsyncReceiver <int>(
componentA,
async x =>
{
await Task.Delay(1);
emitter.Post(x, p.GetCurrentTime());
},
"receiverOnA");
Generators.Return(p, 123).PipeTo(receiver);
p.Run();
}
}
catch (AggregateException ex)
{
exceptionThrown = true;
Assert.AreEqual <int>(1, ex.InnerExceptions.Count);
// since this is an async receiver, exceptions are also wrapped in an AggregateException
var aggEx = ex.InnerExceptions[0] as AggregateException;
Assert.IsNotNull(aggEx);
Assert.AreEqual <int>(1, aggEx.InnerExceptions.Count);
Assert.IsTrue(aggEx.InnerExceptions[0].Message.StartsWith("Emitter of one component unexpectedly received post from a receiver of another component"));
}
Assert.IsTrue(exceptionThrown);
}
private static void PsiVersion()
{
using (var pipeline = Pipeline.Create())
{
var arm = new UArmComponent(pipeline, uarm);
var keys = Generators.Timer(pipeline, TimeSpan.FromMilliseconds(10), (dt, ts) => Console.ReadKey(true).Key);
var pump = false;
keys.Where(k => k == ConsoleKey.P).Select(_ => pump = !pump).PipeTo(arm.Pump);
keys.Where(k => k == ConsoleKey.B).Select(_ => Tuple.Create(500f, 0.1f)).PipeTo(arm.Beep);
keys.Select(k =>
{
switch (k)
{
case ConsoleKey.U: return(Tuple.Create(0f, 0f, -10f));
case ConsoleKey.D: return(Tuple.Create(0f, 0f, 10f));
case ConsoleKey.LeftArrow: return(Tuple.Create(0f, -10f, 0f));
case ConsoleKey.RightArrow: return(Tuple.Create(0f, 10f, 0f));
case ConsoleKey.UpArrow: return(Tuple.Create(-10f, 0f, 0f));
case ConsoleKey.DownArrow: return(Tuple.Create(10f, 0f, 0f));
default: return(null);
}
}).Where(p => p != null).PipeTo(arm.RelativePosition);
arm.PositionChanged.Do(p => Console.WriteLine($"Position: x={p.Item1} y={p.Item2} z={p.Item3}"));
var quit = false;
keys.Where(k => k == ConsoleKey.Q).Do(_ => quit = true);
pipeline.RunAsync();
while (!quit)
{
Thread.Sleep(100);
}
}
}
public void RealTimePlayback()
{
var count = 10;
var spacing = TimeSpan.FromMilliseconds(5);
var name = nameof(this.RealTimePlayback);
using (var p = Pipeline.Create("write"))
{
var writeStore = Store.Create(p, name, this.path);
var seq = Generators.Sequence(p, 1, i => i + 1, count, spacing);
seq.Write("seq", writeStore);
p.Run();
}
// now replay the contents and verify we get something
int replayCount = 0;
bool spaced = true;
using (var p2 = Pipeline.Create("read"))
{
var readStore = Store.Open(p2, name, this.path);
var playbackInterval = readStore.OriginatingTimeInterval;
var seq2 = readStore.OpenStream <int>("seq");
var verifier = seq2.Do(
(s, e) =>
{
var now = Time.GetCurrentTime();
var realTimeDelta = (now - p2.Clock.RealTimeOrigin).Ticks;
var messageDelta = (e.Time - p2.Clock.Origin).Ticks;
spaced = spaced && realTimeDelta >= messageDelta;
replayCount++;
});
p2.Run(playbackInterval, true);
}
Assert.IsTrue(spaced);
Assert.AreEqual(count, replayCount);
}
private void NetMQTransportTest()
{
const string topic = "test-topic";
string address = "tcp://localhost:12345";
// start client
ListObservable <double> results;
var complete = false;
using (var p = Pipeline.Create())
{
Console.WriteLine("Starting client...");
var client = new NetMQSource <double>(p, topic, address, JsonFormat.Instance);
client.Do(x => complete = (x == 9)).Do(x => Console.WriteLine($"MSG: {x}"));
results = client.ToObservable().ToListObservable();
p.RunAsync();
Thread.Sleep(1000); // give time to open TCP port
// start server - run to end of finite generator
Console.WriteLine("Starting server...");
using (var q = Pipeline.Create())
{
var gen = Generators.Range(q, 0, 10, TimeSpan.FromMilliseconds(10)).Select(x => (double)x);
var server = new NetMQWriter <double>(q, topic, address, JsonFormat.Instance);
gen.PipeTo(server);
q.Run();
}
Console.WriteLine("Waiting...");
while (!complete)
{
Thread.Sleep(100);
}
}
Assert.IsTrue(Enumerable.SequenceEqual(results.AsEnumerable(), new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }));
}
public static void MusicMod(WavFile musik, WavFile musik1, MelodyModell Mod)
{
for (int i = 0; i < musik.DataList.Count; i++)
{
musik.DataList[i] = (Int16)((musik.DataList[i] * 3) / 7);
}
var datM = musik1.DataList.Select(v => { return((double)v); }).ToArray();
for (int i = 1; 2 * (i * Mod.BPMd) < musik.DataList.Count - Mod.BPMd; i++)
{
var maxCh = NoteDetector.DetectNote(Mod.BPMd, datM, i, Mod.BPMd);
var Bit = Generators.MusicImmitation(1 << 14, (int)((1 << 14) / (220 / 2.69 * ((i % 3 + 2) * 0.1))) /*Math.Max(maxCh,1)*/, 5000, 10);
for (int j = 0; j < Bit.Length && musik.DataList.Count > (i * Mod.BPMd + j + Mod.StartSd) * 2; j++)
{
musik.DataList[2 * (i * Mod.BPMd + j)] = (Int16)((Bit[j] * 4 / 7d + musik.DataList[2 * (i * Mod.BPMd + j) /*+ Mod.StartSd*/]));
musik.DataList[2 * (i * Mod.BPMd + j) + 1] = (Int16)((Bit[j] * 4 / 7d + musik.DataList[2 * (i * Mod.BPMd + j) + 1 /*+ Mod.StartSd*/]));
}
}
}
public PolygonManagementViewModel(IUnityContainer container = null, AreaCalculator areaCalculator = null)
{
Polygons = new ObservableCollection <Polygon>();
GenerateAndAddPolygonCommand = new DelegateCommand(
GenerateAndAddPolygon,
() => SelectedPolygonGenerator != null);
Calculator = areaCalculator;
CalculateAreaForSelectedPolygonCommand = new DelegateCommand(
CalculateAreaForSelectedPolygon,
() => Calculator != null && SelectedPolygon != null && !IsCalculatingArea);
CancelAreaCalculationCommand = new DelegateCommand(
() => CancelSource?.Cancel(),
() => IsCalculatingArea);
if (container != null)
{
Generators = GetGeneratorsFromContainer(container);
SelectedPolygonGenerator = Generators.LastOrDefault()?.Generator;
}
}
private void NormalMap_Status(object sender, Generators.ProgressEventArgs e)
{
pictureBox2.Invoke((MethodInvoker)delegate
{
pictureBox2.ProgressBar_Value = e.Status;
if (e.Status == 100)
{
pictureBox2.ProgressBar_Visible = false;
}
else
{
pictureBox2.ProgressBar_Visible = true;
}
pictureBox2.Refresh();
});
if (e.Preview == null) return;
//Show In RealTime
pictureBox5.Invoke((MethodInvoker)delegate
{
var oldImage = pictureBox5.Image;
pictureBox5.Image = e.Preview;
if (oldImage != null)
((IDisposable)oldImage).Dispose();
pictureBox5.Refresh();
});
}
public void Postprocess(Generators.Generator generator)
{
}
