public MetaSlabs(ObjectSet mos, long metaSlabArray, int metaSlabShift, int aShift)
{
mMos = mos;
mSlabSize = 1L << metaSlabShift;
var slabDnode = mos.ReadEntry(metaSlabArray);
var someBytes = Program.RentBytes(checked((int)slabDnode.AvailableDataSize));
slabDnode.Read(someBytes, 0);
int numberOfSlabs = someBytes.Count / 8;
mRangeMap = new RangeMap[numberOfSlabs];
long[] ids = new long[numberOfSlabs];
Buffer.BlockCopy(someBytes.Array, someBytes.Offset, ids, 0, someBytes.Count);
Program.ReturnBytes(someBytes);
someBytes = default(ArraySegment<byte>);
for (int i = 0; i < numberOfSlabs; i++)
{
var id = ids[i];
RangeMap map;
if (id == 0)
{
map = new RangeMap();
}
else
{
map = LoadEntrysForMetaSlab(id, aShift);
}
mRangeMap[i] = map;
}
}
/// <summary>
/// Loads, but does not start, an implant by vpath, returning the loaded object
/// </summary>
public JavascriptImplant Load(string vpath, RangeMap range, string oscFormat = "/osc/{x}/{y}")
{
lock (Items)
{
var implant = new JavascriptImplant(vpath, oscFormat, range);
Items.Add(implant);
return(implant);
}
}
public void RangeMapLadenUndSpeichern()
{
var r = new RangeMap<string>();
r.Add(new Range(1, 3), "schwarz");
r.Add(new Range(4, 7), "braun");
var filename="TestRangeMap.xml";
ObjectExtentions.SaveToXml(r, filename);
var rGeladen = ObjectExtentions.LoadFromXml <RangeMap<string>>(filename);
}
public Implant(RangeMap activeArea)
{
if (activeArea == null)
{
throw new ArgumentNullException("RangeMap");
}
ImplantID = string.Format("implant_{0:##}", nextId++);
ActiveArea = activeArea;
}
public void NavigateTo()
{
Location lLoc = new Location();
lLoc.Latitude = Latitude;
lLoc.Longitude = Longitude;
RangeMap.Center = lLoc;
RangeMap.LocationToViewportPoint(lLoc);
RangeMap.ZoomLevel = 16;
}
public void CheckOverlapStartAfterRange()
{
RangeMap map = new RangeMap();
map.AddRange(10, 11); // - 20
map.AddRange(30, 11); // - 40
map.AddRange(50, 11); // - 60
// Start before first range
Assert.IsTrue(map.OverlapsRange(60, 2));
Assert.IsFalse(map.OverlapsRange(61, 7));
Assert.IsFalse(map.OverlapsRange(100, 7));
}
/// <summary>
/// Loads the javascript file to be run, but does not start it.
/// If the vpath starts with "~", then the filename is relative
/// to the plugins folder.
/// </summary>
public JavascriptImplant(string vpath, string oscFormat, RangeMap activeArea) : base(activeArea)
{
// override the implant ID with something more useful
#warning This ImplantID will not be unique if the same implant is loaded twice!!!
ImplantID = vpath;
Active = true;
ImplantType = JavascriptImplantType.Load(vpath);
ImplantInstance = ImplantType.CreateInstance(this);
ImplantInstance.osc.Format = oscFormat;
}
public void CheckOverlapStartAfterRange()
{
RangeMap map = new RangeMap();
map.AddRange(10, 11); // - 20
map.AddRange(30, 11); // - 40
map.AddRange(50, 11); // - 60
// Start before first range
Assert.IsTrue(map.OverlapsRange(60, 2));
Assert.IsFalse(map.OverlapsRange(61, 7));
Assert.IsFalse(map.OverlapsRange(100, 7));
}
IEnumerable <byte> GenerateTableOfContents(IEnumerable <MpegAudioDataFrame> mpegAudioDataFrames)
{
double totalDataLength = mpegAudioDataFrames.Sum(frame => frame.TotalLength);
double totalTimeLength = mpegAudioDataFrames.Sum(frame => frame.AudioLength);
IMap <double, double> toAbsoluteTime = new RangeMap(new OrderedRange <double>(0, 99), new OrderedRange <double>(0, totalTimeLength), Mappers.Linear);
IMap <double, double> toRelativeData = new RangeMap(new OrderedRange <double>(0, totalDataLength), new OrderedRange <double>(0, 255), Mappers.Linear);
for (int index = 0; index < 100; index++)
{
yield return((byte)toRelativeData.Map(GetDataPosition(mpegAudioDataFrames, toAbsoluteTime.Map(index))).Round());
}
}
public void RangeOverlap3()
{
RangeMap map = new RangeMap();
map.AddRange(10, 11);
map.AddRange(30, 11);
map.AddRange(50, 11);
map.AddRange(15, 41);
Assert.AreEqual(1, map.Ranges.Count);
Assert.AreEqual(10, map.Ranges[0].From);
Assert.AreEqual(60, map.Ranges[0].To);
}
public void RangeOverlap5()
{
RangeMap map = new RangeMap();
map.AddRange(10, 11);
map.AddRange(22, 9);
map.AddRange(32, 9);
map.AddRange(21, 11);
Assert.AreEqual(1, map.Ranges.Count);
Assert.AreEqual(10, map.Ranges[0].From);
Assert.AreEqual(40, map.Ranges[0].To);
}
public void Insert()
{
var map = new RangeMap();
map.Set(10, 10);
map.Set(30, 10);
map.Set(50, 10);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 10), new Range(30, 10), new Range(50, 10) }));
map.Insert(35, 10);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 10), new Range(30, 20), new Range(60, 10) }));
map.Insert(25, 10);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 10), new Range(40, 20), new Range(70, 10) }));
}
public void Set()
{
var map = new RangeMap();
map.Set(10, 5);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 5) }));
map.Set(20, 5);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 5), new Range(20, 5) }));
map.Set(15, 5);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 15) }));
map.Set(5, 25);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(5, 25) }));
}
public void RangeAfter()
{
RangeMap map = new RangeMap();
map.AddRange(5, 6);
map.AddRange(15, 3);
map.AddRange(20, 3);
Assert.AreEqual(3, map.Ranges.Count);
Assert.AreEqual(5, map.Ranges[0].From);
Assert.AreEqual(10, map.Ranges[0].To);
Assert.AreEqual(15, map.Ranges[1].From);
Assert.AreEqual(17, map.Ranges[1].To);
Assert.AreEqual(20, map.Ranges[2].From);
Assert.AreEqual(22, map.Ranges[2].To);
}
public void RangeAfter()
{
RangeMap map = new RangeMap();
map.AddRange(5, 6);
map.AddRange(15, 3);
map.AddRange(20, 3);
Assert.AreEqual(3, map.Ranges.Count);
Assert.AreEqual(5, map.Ranges[0].From);
Assert.AreEqual(10, map.Ranges[0].To);
Assert.AreEqual(15, map.Ranges[1].From);
Assert.AreEqual(17, map.Ranges[1].To);
Assert.AreEqual(20, map.Ranges[2].From);
Assert.AreEqual(22, map.Ranges[2].To);
}
public void RangeOverlap2()
{
RangeMap map = new RangeMap();
map.AddRange(10, 11);
map.AddRange(30, 11);
map.AddRange(50, 11);
map.AddRange(5, 25);
Assert.AreEqual(2, map.Ranges.Count);
Assert.AreEqual(5, map.Ranges[0].From);
Assert.AreEqual(40, map.Ranges[0].To);
Assert.AreEqual(50, map.Ranges[1].From);
Assert.AreEqual(60, map.Ranges[1].To);
}
public void Unset()
{
var map = new RangeMap();
map.Set(10, 50);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 50) }));
map.Unset(20, 10);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 10), new Range(30, 30) }));
map.Unset(40, 10);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 10), new Range(30, 10), new Range(50, 10) }));
map.Unset(15, 40);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 5), new Range(55, 5) }));
}
private void MapWithPushpins_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
// Disables the default mouse double-click action.
e.Handled = true;
// Determin the location to place the pushpin at on the map.
//Get the mouse click coordinates
Point mousePosition = e.GetPosition(this);
//Convert the mouse coordinates to a locatoin on the map
Location pinLocation = RangeMap.ViewportPointToLocation(mousePosition);
// The pushpin to add to the map.
bool shooter = false;
bool target = false;
foreach (Pushpin lpp in RangeMap.Children)
{
if (lpp.Name == "Shooter")
{
shooter = true;
}
if (lpp.Name == "Target")
{
target = true;
}
}
if (!shooter)
{
Pushpin ShooterLoc = new Pushpin();
ShooterLoc.Location = pinLocation;
ShooterLoc.Name = "Shooter";
ShooterLoc.Content = "Shooter";
// Adds the pushpin to the map.
RangeMap.Children.Add(ShooterLoc);
}
else if (!target)
{
Pushpin TargetLoc = new Pushpin();
TargetLoc.Location = pinLocation;
TargetLoc.Name = "Target";
TargetLoc.Content = "Target";
// Adds the pushpin to the map.
RangeMap.Children.Add(TargetLoc);
}
}
// ********************************************************************************
/// <summary>
/// Checks target language for forbidden terms
/// </summary>
/// <param name="src"></param>
/// <param name="trn"></param>
/// <param name="token"></param>
/// <param name="checker"></param>
/// <created>UPh,20.03.2016</created>
/// <changed>UPh,20.03.2016</changed>
// ********************************************************************************
public void DoCheckProhibitedTerm(string text, CPAIToken token, CPAITokenCheck checker)
{
RangeMap ranges = new RangeMap();
List <TerminologyResultArgs> results = _Query.RequestSyncProhibitedTerminology(text, 0);
// Results come sorted by word range. Longer sections (number of words in term) come first
foreach (TerminologyResultArgs result in results)
{
if (result.Status != TermStatus.prohibited)
{
continue;
}
checker.ErrorOutput(token, string.Format("ET: Prohibited term used: {0}", result.Term1));
}
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="src"></param>
/// <param name="trn"></param>
/// <returns></returns>
/// <created>UPh,29.11.2015</created>
/// <changed>UPh,29.11.2015</changed>
// ********************************************************************************
public void DoCheckTermUsage(string src, string trn, CPAIToken token, CPAITokenCheck checker)
{
RangeMap ranges = new RangeMap();
List <TerminologyResultArgs> results = _Query.RequestSyncTerminology(src, 0);
int _CurrentFrom = -1;
int _CurrentLen = -1;
string strMissingTerm = "";
// Results come sorted by word range. Longer sections (number of words in term) come first
foreach (TerminologyResultArgs result in results)
{
if (ranges.OverlapsRange(result.FindFrom, result.FindLen))
{
continue; // Range already checked
}
if (_CurrentFrom != result.FindFrom ||
_CurrentLen != result.FindLen)
{
if (strMissingTerm.Length > 0)
{
checker.ErrorOutput(token, string.Format("ET: Missing term {0}", strMissingTerm));
}
strMissingTerm = "";
_CurrentFrom = result.FindFrom;
_CurrentLen = result.FindLen;
strMissingTerm = src.Substring(_CurrentFrom, _CurrentLen);
}
if (trn.IndexOf(result.Term2, StringComparison.InvariantCultureIgnoreCase) >= 0)
{
// Term found. Mark section as ok
ranges.AddRange(result.FindFrom, result.FindLen);
strMissingTerm = "";
}
}
if (strMissingTerm.Length > 0)
{
checker.ErrorOutput(token, string.Format("ET: Missing term {0}", strMissingTerm));
}
}
public void Delete()
{
var map = new RangeMap();
map.Set(10, 10);
map.Set(30, 10);
map.Set(50, 10);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 10), new Range(30, 10), new Range(50, 10) }));
map.Delete(35, 5);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 10), new Range(30, 5), new Range(45, 10) }));
map.Delete(20, 5);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 10), new Range(25, 5), new Range(40, 10) }));
map.Delete(15, 30);
Assert.That(new List <Range>(map), Is.EquivalentTo(new Range[] { new Range(10, 10) }));
}
public void CanMapToMqtt(decimal mqttMin, decimal mqttMax, string googleValue, object value, string expectedResult)
{
// Arrange
var mapper = new RangeMap
{
Google = googleValue,
MqttMin = mqttMin,
MqttMax = mqttMax
};
// Act
var matches = mapper.MatchesGoogle(value);
var result = mapper.ConvertToMqtt(value);
// Assert
Assert.True(matches);
Assert.Equal(expectedResult, result);
}
public void CheckOverlapStartBeforeRange()
{
RangeMap map = new RangeMap();
map.AddRange(10, 11); // - 20
map.AddRange(30, 11); // - 40
map.AddRange(50, 11); // - 60
// Start before first range
Assert.IsFalse(map.OverlapsRange(5, 5)); // - 9
Assert.IsTrue(map.OverlapsRange(5, 6)); // - 10
Assert.IsTrue(map.OverlapsRange(5, 21)); // - 25
Assert.IsTrue(map.OverlapsRange(5, 80)); // - 84
// Start before last range
Assert.IsFalse(map.OverlapsRange(45, 5)); // - 49
Assert.IsTrue(map.OverlapsRange(45, 6)); //
Assert.IsTrue(map.OverlapsRange(45, 21)); //
Assert.IsTrue(map.OverlapsRange(45, 80)); //
}
public void CheckOverlapStartInRange()
{
RangeMap map = new RangeMap();
map.AddRange(10, 11); // - 20
map.AddRange(30, 11); // - 40
map.AddRange(50, 11); // - 60
// Start before first range
Assert.IsTrue(map.OverlapsRange(15, 2));
Assert.IsTrue(map.OverlapsRange(15, 7));
Assert.IsTrue(map.OverlapsRange(15, 15));
Assert.IsTrue(map.OverlapsRange(15, 80));
// Start in last range
Assert.IsTrue(map.OverlapsRange(55, 2));
Assert.IsTrue(map.OverlapsRange(55, 7));
Assert.IsTrue(map.OverlapsRange(55, 15));
Assert.IsTrue(map.OverlapsRange(55, 80));
}
static Krach.Graphics.Color StretchColor(double stretchFactor)
{
Krach.Graphics.Color baseColor = Krach.Graphics.Color.FromHsv(0, 0, 0);
OrderedRange <double> source = new OrderedRange <double>(0.75, 1.0);
OrderedRange <double> destination = new OrderedRange <double>(0.0, 1.0);
IMap <double, double> amplifier = new RangeMap(source, destination, Mappers.Linear);
if (stretchFactor < 1)
{
return(Krach.Graphics.Color.InterpolateRgb(Colors.Blue, baseColor, Scalars.InterpolateLinear, amplifier.Map((1.0 * stretchFactor).Clamp(source))));
}
if (stretchFactor > 1)
{
return(Krach.Graphics.Color.InterpolateRgb(Colors.Red, baseColor, Scalars.InterpolateLinear, amplifier.Map((1.0 / stretchFactor).Clamp(source))));
}
return(baseColor);
}
public void RangeBetween()
{
RangeMap map = new RangeMap();
map.AddRange(5, 6);
map.AddRange(30, 3);
map.AddRange(15, 3);
Assert.AreEqual(3, map.Ranges.Count);
Assert.AreEqual(5, map.Ranges[0].From);
Assert.AreEqual(10, map.Ranges[0].To);
Assert.AreEqual(15, map.Ranges[1].From);
Assert.AreEqual(17, map.Ranges[1].To);
Assert.AreEqual(30, map.Ranges[2].From);
Assert.AreEqual(32, map.Ranges[2].To);
map.AddRange(20, 5);
Assert.AreEqual(4, map.Ranges.Count);
Assert.AreEqual(20, map.Ranges[2].From);
Assert.AreEqual(24, map.Ranges[2].To);
}
public void CheckOverlapStartInRange()
{
RangeMap map = new RangeMap();
map.AddRange(10, 11); // - 20
map.AddRange(30, 11); // - 40
map.AddRange(50, 11); // - 60
// Start before first range
Assert.IsTrue(map.OverlapsRange(15, 2));
Assert.IsTrue(map.OverlapsRange(15, 7));
Assert.IsTrue(map.OverlapsRange(15, 15));
Assert.IsTrue(map.OverlapsRange(15, 80));
// Start in last range
Assert.IsTrue(map.OverlapsRange(55, 2));
Assert.IsTrue(map.OverlapsRange(55, 7));
Assert.IsTrue(map.OverlapsRange(55, 15));
Assert.IsTrue(map.OverlapsRange(55, 80));
}
public void CheckOverlapStartBeforeRange()
{
RangeMap map = new RangeMap();
map.AddRange(10, 11); // - 20
map.AddRange(30, 11); // - 40
map.AddRange(50, 11); // - 60
// Start before first range
Assert.IsFalse(map.OverlapsRange(5, 5)); // - 9
Assert.IsTrue(map.OverlapsRange(5, 6)); // - 10
Assert.IsTrue(map.OverlapsRange(5, 21)); // - 25
Assert.IsTrue(map.OverlapsRange(5, 80)); // - 84
// Start before last range
Assert.IsFalse(map.OverlapsRange(45, 5)); // - 49
Assert.IsTrue(map.OverlapsRange(45, 6)); //
Assert.IsTrue(map.OverlapsRange(45, 21)); //
Assert.IsTrue(map.OverlapsRange(45, 80)); //
}
unsafe RangeMap LoadEntrysForMetaSlab(long dnEntry, int sm_shift)
{
RangeMap ret = new RangeMap();
var dn = mMos.ReadEntry(dnEntry);
if (dn.Type != dmu_object_type_t.SPACE_MAP || dn.BonusType != dmu_object_type_t.SPACE_MAP_HEADER)
throw new Exception("Not a space map.");
var head = dn.GetBonus<space_map_obj>();
if (head.smo_object != dnEntry)
throw new Exception();
if (head.smo_objsize > int.MaxValue)
throw new Exception("Holy cow, this space map is greater than 2GB, what is wrong with your VDev!?!?");
var someBytes = Program.RentBytes((int)head.smo_objsize);
dn.Read(someBytes, 0);
for (int i = 0; i < someBytes.Count; i += 8)
{
var ent = Program.ToStruct<spaceMapEntry>(someBytes.SubSegment(i, sizeof(spaceMapEntry)));
if (ent.IsDebug)
continue;
ulong offset = (ent.Offset << sm_shift);
ulong range = ent.Run << sm_shift;
//Console.WriteLine("\t [{4,6}] {0} range: {1:x10}-{2:x10} size: {3:x6}", ent.Type, offset, offset + range, range, i / 8);
if (ent.Type == SpaceMapEntryType.A)
{
ret.AddRange(offset, range);
}
else if (ent.Type == SpaceMapEntryType.F)
{
ret.RemoveRange(offset, range);
}
}
Program.ReturnBytes(someBytes);
return ret;
}
RangeMap NewMap()
{
/*
* 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8
* 0 5 0 5 0 5 0 5 0 5 0 5 0 5 0 5 0 5
* .....*****.....*****.....*****.....*****.....*****.....*****.....*****.....*****......
* ......................................................................................
* ......................................................................................
*
* 75
* 05 25 45 65
* 15 55
* 35
*/
var result = new RangeMap();
foreach (var start in new int[] { 35, 15, 55, 5, 25, 45, 65, 75 })
{
result.Set(start, 5);
}
return(result);
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="src"></param>
/// <param name="trn"></param>
/// <returns></returns>
/// <created>UPh,29.11.2015</created>
/// <changed>UPh,29.11.2015</changed>
// ********************************************************************************
public void DoCheckTermUsage(string src, string trn, CPAIToken token, CPAITokenCheck checker)
{
RangeMap ranges = new RangeMap();
List<TerminologyResultArgs> results = _Query.RequestSyncTerminology(src, 0);
int _CurrentFrom = -1;
int _CurrentLen = -1;
string strMissingTerm = "";
// Results come sorted by word range. Longer sections (number of words in term) come first
foreach (TerminologyResultArgs result in results)
{
if (ranges.OverlapsRange(result.FindFrom, result.FindLen))
continue; // Range already checked
if (_CurrentFrom != result.FindFrom ||
_CurrentLen != result.FindLen)
{
if (strMissingTerm.Length > 0)
checker.ErrorOutput(token, string.Format("ET: Missing term {0}", strMissingTerm));
strMissingTerm = "";
_CurrentFrom = result.FindFrom;
_CurrentLen = result.FindLen;
strMissingTerm = src.Substring(_CurrentFrom, _CurrentLen);
}
if (trn.IndexOf(result.Term2, StringComparison.InvariantCultureIgnoreCase) >= 0)
{
// Term found. Mark section as ok
ranges.AddRange(result.FindFrom, result.FindLen);
strMissingTerm = "";
}
}
if (strMissingTerm.Length > 0)
checker.ErrorOutput(token, string.Format("ET: Missing term {0}", strMissingTerm));
}
// ********************************************************************************
/// <summary>
/// Checks target language for forbidden terms
/// </summary>
/// <param name="src"></param>
/// <param name="trn"></param>
/// <param name="token"></param>
/// <param name="checker"></param>
/// <created>UPh,20.03.2016</created>
/// <changed>UPh,20.03.2016</changed>
// ********************************************************************************
public void DoCheckProhibitedTerm(string text, CPAIToken token, CPAITokenCheck checker)
{
RangeMap ranges = new RangeMap();
List<TerminologyResultArgs> results = _Query.RequestSyncProhibitedTerminology(text, 0);
// Results come sorted by word range. Longer sections (number of words in term) come first
foreach (TerminologyResultArgs result in results)
{
if (result.Status != TermStatus.prohibited)
continue;
checker.ErrorOutput(token, string.Format("ET: Prohibited term used: {0}", result.Term1));
}
}
/// <summary>
/// Overwrites the current session settings from a parsed
/// JSON object.
/// </summary>
private static void Deserialize(UserSession session, SessionFileFormat file)
{
// devices must loaded first for implant loaded to work
session.Devices.ClearAll();
foreach (var item in file.devices)
{
try
{
session.Devices.MapByName(item.deviceName, item.mappedAs);
var mapping = session.Devices.GetMappedDeviceByName(item.deviceName);
mapping.Enabled = item.enabled;
}
catch (Exception ex)
{
LPConsole.WriteLine("SessionFile", ex.Message);
}
}
session.Devices.AutoMap();
// load the implants
session.Implants.ClearAll();
foreach (var item in file.implants)
{
RangeMap range;
if (item.activeArea == null)
{
range = new RangeMap(MIDI.MappedMidiDevice.CreateNullDevice());
}
else
{
range = item.activeArea.ToRangeMap();
}
if (item.status != "not loaded")
{
var implant = session.Implants.Load(item.vpath, range, item.oscFormat);
// important to load session values first so the init doesn't screw it up
if (item.doubleValues != null)
{
implant.ImplantInstance.session.DoubleValues.Clear();
foreach (var key in item.doubleValues.Keys)
{
implant.ImplantInstance.session.DoubleValues.Add(key, item.doubleValues[key]);
}
}
if (item.stringValues != null)
{
implant.ImplantInstance.session.StringValues.Clear();
foreach (var key in item.stringValues.Keys)
{
implant.ImplantInstance.session.StringValues.Add(key, item.stringValues[key]);
}
}
implant.AssignedMode = item.assignedMode;
if (item.status == "running")
{
implant.ServerInit();
}
}
}
session.MidiMap.Mappings.Clear();
foreach (var item in file.midiMap)
{
var m = new OscToMidiMap();
m.ID = item.id;
m.OscSource = item.oscSource;
m.OscAddress = item.oscAddress;
m.OscValueFrom = item.oscValueFrom;
m.OscValueTo = item.oscValueTo;
m.MidiDestination = item.midiDestination;
m.MidiType = item.midiType.GetMidiMessageType(); //OscToMidiMap.FromString(item.midiType);
m.MidiNote = item.midiNote;
m.MidiValueFrom = item.midiValueFrom;
m.MidiValueTo = item.midiValueTo;
session.MidiMap.Mappings.Add(m);
}
}
public void RangeBetween()
{
RangeMap map = new RangeMap();
map.AddRange(5, 6);
map.AddRange(30, 3);
map.AddRange(15, 3);
Assert.AreEqual(3, map.Ranges.Count);
Assert.AreEqual(5, map.Ranges[0].From);
Assert.AreEqual(10, map.Ranges[0].To);
Assert.AreEqual(15, map.Ranges[1].From);
Assert.AreEqual(17, map.Ranges[1].To);
Assert.AreEqual(30, map.Ranges[2].From);
Assert.AreEqual(32, map.Ranges[2].To);
map.AddRange(20, 5);
Assert.AreEqual(4, map.Ranges.Count);
Assert.AreEqual(20, map.Ranges[2].From);
Assert.AreEqual(24, map.Ranges[2].To);
}
public void RangeOverlap3()
{
RangeMap map = new RangeMap();
map.AddRange(10, 11);
map.AddRange(30, 11);
map.AddRange(50, 11);
map.AddRange(15, 41);
Assert.AreEqual(1, map.Ranges.Count);
Assert.AreEqual(10, map.Ranges[0].From);
Assert.AreEqual(60, map.Ranges[0].To);
}
public void RangeOverlap4()
{
RangeMap map = new RangeMap();
map.AddRange(10, 11);
map.AddRange(30, 11);
map.AddRange(50, 11);
map.AddRange(21, 9);
Assert.AreEqual(2, map.Ranges.Count);
Assert.AreEqual(10, map.Ranges[0].From);
Assert.AreEqual(40, map.Ranges[0].To);
Assert.AreEqual(50, map.Ranges[1].From);
Assert.AreEqual(60, map.Ranges[1].To);
}
public void RangeOverlap5()
{
RangeMap map = new RangeMap();
map.AddRange(10, 11);
map.AddRange(22, 9);
map.AddRange(32, 9);
map.AddRange(21, 11);
Assert.AreEqual(1, map.Ranges.Count);
Assert.AreEqual(10, map.Ranges[0].From);
Assert.AreEqual(40, map.Ranges[0].To);
}
public void CheckOverlapWithEmptyRanges()
{
RangeMap map = new RangeMap();
Assert.IsFalse(map.OverlapsRange(5, 5));
}
public void CheckOverlapWithEmptyRanges()
{
RangeMap map = new RangeMap();
Assert.IsFalse(map.OverlapsRange(5, 5));
}
