/// <summary>
/// Serializes the current instance to an Xml representation - intended to be persisted in an <see cref="ExtendedDataCollection"/>
/// </summary>
/// <returns>An Xml string</returns>
internal string SerializeToXml()
{
string xml;
using (var sw = new StringWriter())
{
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = true
};
using (var writer = XmlWriter.Create(sw, settings))
{
writer.WriteStartDocument();
writer.WriteStartElement(Constants.ExtendedDataKeys.LineItem);
writer.WriteElementString(Constants.ExtendedDataKeys.ContainerKey, ContainerKey.ToString());
writer.WriteElementString(Constants.ExtendedDataKeys.LineItemTfKey, LineItemTfKey.ToString());
writer.WriteElementString(Constants.ExtendedDataKeys.Sku, Sku);
writer.WriteElementString(Constants.ExtendedDataKeys.Name, Name);
writer.WriteElementString(Constants.ExtendedDataKeys.Quantity, Quantity.ToString(CultureInfo.InvariantCulture));
writer.WriteElementString(Constants.ExtendedDataKeys.Price, Price.ToString(CultureInfo.InvariantCulture));
writer.WriteStartElement(Constants.ExtendedDataKeys.ExtendedData);
writer.WriteRaw(ExtendedData.SerializeToXml());
writer.WriteEndElement();
writer.WriteEndElement(); // ExtendedData
writer.WriteEndDocument();
}
xml = sw.ToString();
}
return(xml);
}
public Exceptionless.Core.Models.Data.StackFrame ToStackFrame()
{
var frame = new Exceptionless.Core.Models.Data.StackFrame {
Name = Name,
ModuleId = ModuleId,
DeclaringNamespace = DeclaringNamespace,
DeclaringType = DeclaringType,
IsSignatureTarget = IsSignatureTarget,
Column = Column,
FileName = FileName,
LineNumber = LineNumber
};
if (GenericArguments != null && GenericArguments.Count > 0)
{
frame.GenericArguments = GenericArguments.ToGenericArguments();
}
if (Parameters != null && Parameters.Count > 0)
{
frame.Parameters = Parameters.ToParameters();
}
if (ExtendedData != null && ExtendedData.Count > 0)
{
frame.Data.AddRange(ExtendedData.ToData());
}
return(frame);
}
public Exceptionless.Models.Data.InnerError ToInnerError()
{
var error = new Exceptionless.Models.Data.InnerError {
Message = Message,
Type = Type,
Code = Code,
};
if (StackTrace != null && StackTrace.Count > 0)
{
error.StackTrace = StackTrace.ToStackTrace();
}
if (TargetMethod != null)
{
error.TargetMethod = TargetMethod.ToMethod();
}
if (Inner != null)
{
error.Inner = Inner.ToInnerError();
}
if (ExtendedData != null && ExtendedData.Count > 0)
{
error.Data.AddRange(ExtendedData.ToData());
}
return(error);
}
public void Serializer_InheritType_Success()
{
Serializer serializer = new Serializer();
ExtendedData extended = new ExtendedData();
extended.Created = DateTime.UtcNow;
extended.Id = "1";
extended.Extended = new System.Collections.Generic.Dictionary <string, object>();
extended.Extended.Add("key1", new object());
extended.WorkToDo = new Processes();
extended.WorkToDo.Name = "Processes";
extended.WorkToDo.Priority = 1;
extended.WorkToDo.StartDate = DateTime.Now;
extended.WorkToDo.Collection.Add(new Data()
{
Id = "dataCreatedInsideCOllection", Created = DateTime.UtcNow
});
var serialized = serializer.Serialize <ExtendedData>(extended);
Assert.NotNull(serialized);
Assert.Equal(104, serialized.Length);
var deserialized = serializer.Deserialize <ExtendedData>(serialized);
}
public Exceptionless.Models.Data.Method ToMethod()
{
var module = new Exceptionless.Models.Data.Method {
Name = Name,
ModuleId = ModuleId,
DeclaringNamespace = DeclaringNamespace,
DeclaringType = DeclaringType,
IsSignatureTarget = IsSignatureTarget
};
if (GenericArguments != null && GenericArguments.Count > 0)
{
module.GenericArguments = GenericArguments.ToGenericArguments();
}
if (Parameters != null && Parameters.Count > 0)
{
module.Parameters = Parameters.ToParameters();
}
if (ExtendedData != null && ExtendedData.Count > 0)
{
module.Data.AddRange(ExtendedData.ToData());
}
return(module);
}
private void EnsureExtendedData()
{
if (this.extendedData == null)
{
this.extendedData = new ExtendedData();
}
}
public static void Postfix(Ammo __instance, bool __result, Identifiable.Id id, Identifiable identifiable,
int slotIdx, int count, bool overflow)
{
if (!__result)
{
return;
}
if (AmmoIdentifier.TryGetIdentifier(__instance, out var identifier))
{
if (identifiable && ExtendedData.IsRegistered(identifiable.gameObject))
{
var ammo = PersistentAmmoManager.GetPersistentAmmoForAmmo(__instance.ammoModel);
for (int i = 0; i < count; i++)
{
ammo.DataModel.slots[slotIdx]
.PushTop(ExtendedData.extendedActorData[identifiable.GetActorId()]);
}
}
else
{
if (!PersistentAmmoManager.HasPersistentAmmo(identifier))
{
return;
}
var ammo = PersistentAmmoManager.PersistentAmmoData[identifier];
for (int i = 0; i < count; i++)
{
ammo.DataModel.slots[slotIdx].PushTop(null);
}
}
}
}
public override string ToHumanReadableString()
{
switch (Command)
{
case Command.ExtendedCode:
return(String.Format(
"{0}, Category = {1} (0x{2}), Function = {3} (0x{4}), Data = 0x{5}",
base.ToHumanReadableString(),
ExtendedCategoryName,
ExtendedCategoryValue.ToString("X"),
ExtendedFunctionName,
ExtendedFunctionValue.ToString("X"),
ExtendedData.ToString("X").PadLeft(2, '0')));
case Command.StatusOn:
case Command.StatusOff:
return(String.Format(
"{0}, Brightness = {1}%",
base.ToHumanReadableString(),
ExtendedBrightness));
default:
return(String.Format(
"{0}, ExtCommand = 0x{1}, Data = 0x{2}",
base.ToHumanReadableString(),
ExtendedCommand,
ExtendedData));
}
}
public static MapShape CreateUserShape(ShapeData data)
{
var shape = new MapRectangle()
{
Width = data.Width,
Height = data.Height,
Location = new Location(data.Latitude, data.Longitude)
};
var user = data.Tag as entities.User;
if (user != null)
{
var propertySet = new ExtendedPropertySet();
propertySet.RegisterProperty("Placemark.Name", "Name", typeof(string), string.Empty); // KML file defines Placemark.Name, we create a same property too.
var extendedData = new ExtendedData(propertySet);
extendedData.SetValue("Placemark.Name", user.UserName);
shape.ExtendedData = extendedData;
shape.Tag = user;
}
//set CaptionTemplate
shape.CaptionTemplate = Application.Current.FindResource("ShapeCaptionTemplate") as DataTemplate; //In the template, we use ExtendedData["Placemark.Name"] as caption
return(shape);
}
public override string ToString()
{
return
(Convert.ToChar(House) +
NibbleToHex((byte)Unit) +
NibbleToHex((byte)Command) +
"x" +
ExtendedCommand.ToString("X").PadLeft(2, '0') +
"x" +
ExtendedData.ToString("X").PadLeft(2, '0'));
}
internal ExtendedData GetExtendedData(bool create)
{
var data = this.extendedData;
if (data == null && create)
{
var tmp = new ExtendedData();
Interlocked.CompareExchange(ref this.extendedData, tmp, null);
data = this.extendedData;
}
return(data);
}
public void ShouldSaveExistingCustomData()
{
const string Kml = @"<ExtendedData xmlns:prefix='csm'><csm:data>Custom Data</csm:data></ExtendedData>";
var parser = new Parser();
parser.ParseString(Kml, namespaces: false);
ExtendedData data = (ExtendedData)parser.Root;
var serializer = new Serializer();
serializer.SerializeRaw(data);
Assert.That(serializer.Xml, Contains.Substring("Custom Data"));
}
internal ExtendedData GetExtendedData(bool create)
{
var data = this.parent as ExtendedData;
if (data == null && create)
{
data = new ExtendedData {
Parent = this.parent as SyntaxNode
};
Interlocked.CompareExchange(ref this.parent, data, this.parent);
data = this.parent as ExtendedData;
}
return(data);
}
private void FillInformationLayer()
{
// Create extended property set.
// It can be shared between the number
// of the map shapes.
ExtendedPropertySet propertySet = new ExtendedPropertySet();
propertySet.RegisterProperty("Name", "City Name", typeof(string), String.Empty);
propertySet.RegisterProperty("Population", "Population", typeof(int), 0);
MapEllipse sofiaEllipse = new MapEllipse()
{
ShapeFill = new MapShapeFill()
{
Stroke = new SolidColorBrush(Colors.Red),
StrokeThickness = 2,
Fill = new SolidColorBrush(Colors.Transparent)
},
Width = 20,
Height = 20,
Location = new Location(42.6957539183824, 23.3327663758679),
};
// Create extended data for the ellipse
// using existing property set.
ExtendedData sofiaData = new ExtendedData(propertySet);
// Set the extended properties.
sofiaData.SetValue("Name", "Sofia");
sofiaData.SetValue("Population", 1300000);
// Assign extended data to the map shape.
sofiaEllipse.ExtendedData = sofiaData;
// Assign tooltip which uses the extended properties.
ToolTip tooltip = new ToolTip();
Binding tooltipBinding = new Binding()
{
Converter = new ExtendedDataConverter(),
ConverterParameter = "{Name}: {Population} people",
Source = sofiaEllipse.ExtendedData
};
tooltip.SetBinding(System.Windows.Controls.ToolTip.ContentProperty, tooltipBinding);
ToolTipService.SetToolTip(sofiaEllipse, tooltip);
this.informationLayer.Items.Add(sofiaEllipse);
}
public void DeSerializer_InheritType_Success()
{
Serializer serializer = new Serializer();
ExtendedData extended = new ExtendedData();
byte[] array = new byte[] { 194, 62, 85, 58, 8, 10, 4, 107, 101, 121, 49, 18, 0, 66, 73, 194, 62, 13, 90, 11, 8, 134, 214, 153, 165, 169, 162, 151, 54, 16, 5, 74, 9, 80, 114, 111, 99, 101, 115, 115, 101, 115, 80, 1, 90, 42, 42, 27, 100, 97, 116, 97, 67, 114, 101, 97, 116, 101, 100, 73, 110, 115, 105, 100, 101, 67, 79, 108, 108, 101, 99, 116, 105, 111, 110, 50, 11, 8, 252, 212, 246, 136, 157, 160, 151, 54, 16, 5, 42, 1, 49, 50, 11, 8, 168, 232, 243, 136, 157, 160, 151, 54, 16, 5 };
var instance = serializer.Deserialize <ExtendedData>(array);
Assert.NotNull(instance);
Assert.Equal("1", instance.Id);
Assert.NotNull(instance.WorkToDo);
Assert.NotNull(instance.Extended);
}
public void ShouldAllowTheReadingOfCustomData()
{
const string Kml = @"<ExtendedData xmlns:camp='http://www.example.com'><camp:site number='14'>Name</camp:site></ExtendedData>";
var parser = new Parser();
parser.ParseString(Kml, namespaces: false);
ExtendedData data = (ExtendedData)parser.Root;
UnknownElement[] customData = data.OtherData.ToArray();
Assert.That(customData, Has.Length.EqualTo(1));
Assert.That(customData[0].UnknownData.Name, Is.EqualTo("site"));
Assert.That(customData[0].InnerXml, Is.EqualTo("Name"));
Assert.That(customData[0].Attributes.Single().Name, Is.EqualTo("number"));
Assert.That(customData[0].Attributes.Single().Value, Is.EqualTo("14"));
}
private void FillInformationLayer()
{
// Create extended property set.
// It can be shared between the number
// of the map shapes.
ExtendedPropertySet propertySet = new ExtendedPropertySet();
propertySet.RegisterProperty("Name", "City Name", typeof(string), String.Empty);
propertySet.RegisterProperty("Population", "Population", typeof(int), 0);
MapEllipse sofiaEllipse = new MapEllipse()
{
ShapeFill = new MapShapeFill()
{
Stroke = new SolidColorBrush(Colors.Red),
StrokeThickness = 2,
Fill = new SolidColorBrush(Colors.Transparent)
},
Width = 20,
Height = 20,
Location = new Location(42.6957539183824, 23.3327663758679),
};
// Create extended data for the ellipse
// using existing property set.
ExtendedData sofiaData = new ExtendedData(propertySet);
// Set the extended properties.
sofiaData.SetValue("Name", "Sofia");
sofiaData.SetValue("Population", 1300000);
// Assign extended data to the map shape.
sofiaEllipse.ExtendedData = sofiaData;
// Assign tooltip which uses the extended properties.
ToolTip tooltip = new ToolTip();
Binding tooltipBinding = new Binding()
{
Converter = new ExtendedDataConverter(),
ConverterParameter = "{Name}: {Population} people",
Source = sofiaEllipse.ExtendedData
};
tooltip.SetBinding(System.Windows.Controls.ToolTip.ContentProperty, tooltipBinding);
ToolTipService.SetToolTip(sofiaEllipse, tooltip);
this.informationLayer.Items.Add(sofiaEllipse);
}
/// <summary>
/// Creates an ExtendedData KML element from a graphic's attributes.
/// </summary>
/// <param name="attributes">A dictionary of graphic attributes</param>
/// <returns></returns>
public static ExtendedData ToExtendedData(Dictionary <string, object> attributes)
{
var datas = from kvp in attributes
where !_geometryInNameRe.IsMatch(kvp.Key)
select new Data
{
Name = kvp.Key,
//Value = kvp.Value?.ToString() // VS 2015
Value = kvp.Value != null?kvp.Value.ToString() : null
};
var xData = new ExtendedData();
foreach (var data in datas)
{
xData.AddData(data);
}
return(xData);
}
public Exceptionless.Core.Models.Data.Parameter ToParameter()
{
var frame = new Exceptionless.Core.Models.Data.Parameter {
Name = Name,
Type = Type,
TypeNamespace = TypeNamespace
};
if (GenericArguments != null && GenericArguments.Count > 0)
{
frame.GenericArguments = GenericArguments.ToGenericArguments();
}
if (ExtendedData != null && ExtendedData.Count > 0)
{
frame.Data.AddRange(ExtendedData.ToData());
}
return(frame);
}
public static void Postfix(Ammo __instance, bool __result, Identifiable.Id id, Identifiable identifiable)
{
if (!__result)
{
return;
}
if (AmmoIdentifier.TryGetIdentifier(__instance, out var identifier))
{
var count = -1;
for (int i = 0; i < __instance.Slots.Length; i++)
{
if (__instance.Slots[i]?.id == id)
{
count = i;
break;
}
}
if (count == -1)
{
throw new Exception();
}
if (identifiable && ExtendedData.HasExtendedData(identifiable.gameObject))
{
var ammo = PersistentAmmoManager.GetPersistentAmmoForAmmo(__instance.ammoModel);
ammo.DataModel.slots[count].PushTop(ExtendedData.ReadDataFromGameObject(identifiable.gameObject));
ammo.Sync();
}
else
{
if (!PersistentAmmoManager.HasPersistentAmmo(identifier))
{
return;
}
var ammo = PersistentAmmoManager.GetPersistentAmmoForAmmo(__instance.ammoModel);
ammo.DataModel.slots[count].PushTop(null);
ammo.Sync();
}
}
}
/// <summary>
/// Registers Properties for Heat Map
/// </summary>
/// <param name="shape">Map Shape</param>
private void SetAdditionalData(MapShape shape)
{
ExtendedData data = shape.ExtendedData;
if (data != null)
{
if (!data.PropertySet.ContainsKey(COUNTRY_PERFORMANCE_FIELD))
{
data.PropertySet.RegisterProperty(COUNTRY_PERFORMANCE_FIELD, "CountryPerformance", typeof(int), 0);
}
if (!data.PropertySet.ContainsKey(COUNTRY_YTD_FIELD))
{
data.PropertySet.RegisterProperty(COUNTRY_YTD_FIELD, "CountryYTD", typeof(Decimal), Convert.ToDecimal(0));
}
if (!data.PropertySet.ContainsKey(BENCHMARK_YTD_FIELD))
{
data.PropertySet.RegisterProperty(BENCHMARK_YTD_FIELD, "BenchmarkYTD", typeof(Decimal), Convert.ToDecimal(0));
}
if (heatMapInfo != null)
{
string countryID = (string)shape.ExtendedData.GetValue("ISO_2DIGIT");
HeatMapData countryRecord = heatMapInfo.Where(r => r.CountryID == countryID).FirstOrDefault();
if (countryRecord != null)
{
shape.ExtendedData.SetValue(COUNTRY_PERFORMANCE_FIELD, (int)(countryRecord.CountryPerformance));
shape.ExtendedData.SetValue(COUNTRY_YTD_FIELD, countryRecord.CountryYTD);
shape.ExtendedData.SetValue(BENCHMARK_YTD_FIELD, countryRecord.BenchmarkYTD);
AddColorizerToInformationLayer(shape, countryRecord);
}
else
{
shape.ExtendedData.SetValue(COUNTRY_PERFORMANCE_FIELD, null);
shape.ExtendedData.SetValue(COUNTRY_YTD_FIELD, null);
shape.ExtendedData.SetValue(BENCHMARK_YTD_FIELD, null);
AddTransparentColorizerToInformationLayer(shape);
}
}
}
}
public static void Postfix(Ammo __instance, bool __result, Identifiable.Id id, Identifiable identifiable,
int slotIdx, int count, bool overflow)
{
if (!__result)
{
return;
}
if (AmmoIdentifier.TryGetIdentifier(__instance, out var identifier))
{
if (identifiable && ExtendedData.HasExtendedData(identifiable.gameObject))
{
var ammo = PersistentAmmoManager.GetPersistentAmmoForAmmo(__instance.ammoModel);
if (ammo == null)
{
return;
}
for (int i = 0; i < count; i++)
{
ammo.DataModel.slots[slotIdx]
.PushTop(ExtendedData.ReadDataFromGameObject(identifiable.gameObject));
}
ammo.Sync();
}
else
{
if (!PersistentAmmoManager.HasPersistentAmmo(identifier))
{
return;
}
var ammo = PersistentAmmoManager.PersistentAmmoData[identifier];
for (int i = 0; i < count; i++)
{
ammo.DataModel.slots[slotIdx].PushTop(null);
}
ammo.Sync();
}
}
}
public PlacemarkRoute(List <GpsPointData> route, string lineStyleMapId) : this()
{
TimeSpan duration = route.Last().FixTime - route.First().FixTime;
name = "Route";
description = "Duration: " + duration;
styleUrl = "#" + lineStyleMapId;
extendedData = new ExtendedData()
{
data = new ExtendedData.KmlData[]
{
new ExtendedData.KmlData()
{
name = "Start Time", value = route.First().FixTime.ToString("s")
},
new ExtendedData.KmlData()
{
name = "Average Speed", value = AverageSpeed(route).ToString("0.0 mph")
},
}
};
lineString = new LineString(route);
}
public PlacemarkPoint(List <GpsPointData> gps, int idx,
string iconStyleMapNameGreen, string iconStyleMapNameYellow, string iconStyleMapNameRed)
: this()
{
TimeSpan duration = (gps[idx].FixTime - gps[0].FixTime);
name = "Location: " + idx;
description = string.Format("Point {0} from start", duration);
styleUrl = "#" + PointColor(gps[idx], iconStyleMapNameGreen, iconStyleMapNameYellow, iconStyleMapNameRed);
extendedData = new ExtendedData()
{
data = new ExtendedData.KmlData[]
{
new ExtendedData.KmlData()
{
name = "TimeStamp", value = gps[idx].FixTime.ToString()
},
new ExtendedData.KmlData()
{
name = "Speed", value = gps[idx].SpeedMph.ToString("0.0 mph")
},
new ExtendedData.KmlData()
{
name = "Heading", value = gps[idx].Course.ToString("0.0")
},
new ExtendedData.KmlData()
{
name = "Lattitude", value = gps[idx].Latitude.ToString("0.000000")
},
new ExtendedData.KmlData()
{
name = "Longtitude", value = gps[idx].Longitude.ToString("0.000000")
}
}
};
point = new KmlPoint(gps[idx]);
}
public void Read(BinaryReader reader)
{
data.Clear();
var count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
bool shouldbenull = reader.ReadBoolean();
if (shouldbenull)
{
data.Add(null);
}
else
{
var piece = DataPiece.Deserialize(reader) as CompoundDataPiece;
ExtendedData.CullMissingModsFromData(piece);
if (piece.DataList.Count == 0)
{
piece = null;
}
data.Add(piece);
}
}
}
public static void Postfix(GameModel __instance, long actorId, GameObject gameObj, bool skipNotify)
{
ExtendedData.OnRegisterActor(__instance, actorId, gameObj, skipNotify);
}
public ExtendedValue GetExtendedValue(string attributeName)
{
ExtendedData.TryGetValue(attributeName, out var value);
return(value);
}
/// <summary>
/// converte la feature class in kml. Se non sono presenti le coordinate il dato non viene inserito
/// </summary>
/// <param name="sourceWorkspace">workspace con la feature class</param>
/// <param name="outputName">nome della feature class e del csv di output</param>
/// <param name="targetPath">percorso dove salvare il file di output</param>
/// <param name="delimitator">delimitatore utilizzato nel csv</param>
private void ConvertFeatureClassPointToKml(IWorkspace sourceWorkspace, string outputName, string targetPath)
{
IFeatureCursor featureCursor = null;
try
{
IFeatureWorkspace featureWorkspace = sourceWorkspace as IFeatureWorkspace;
IFeatureClass featureClass = featureWorkspace.OpenFeatureClass(outputName);
if (featureClass.ShapeType != esriGeometryType.esriGeometryPoint)
{
throw new Exception($"Per esportare in {Enum.GetName(typeof(FileExtension), FileExtension.kmz)} occorre una feature class di tipo {Enum.GetName(typeof(esriGeometryType), esriGeometryType.esriGeometryPoint)}!");
}
featureCursor = featureClass.Search(null, true);
var folder = new Folder();
folder.Id = outputName;
folder.Name = outputName;
Dictionary <int, string> fields = new Dictionary <int, string>();
IField field = null;
for (int i = 0; i < featureCursor.Fields.FieldCount; i++)
{
field = featureCursor.Fields.Field[i];
if ((field.Type == esriFieldType.esriFieldTypeBlob) || (field.Type == esriFieldType.esriFieldTypeGeometry) ||
(field.Type == esriFieldType.esriFieldTypeGlobalID) || (field.Type == esriFieldType.esriFieldTypeGUID) ||
(field.Type == esriFieldType.esriFieldTypeRaster) || (field.Type == esriFieldType.esriFieldTypeXML))
{
continue;
}
fields.Add(i, field.Name);
}
IFeature feature = null;
Placemark placemark = null;
Vector vector = null;
ExtendedData extendedData = null;
while ((feature = featureCursor.NextFeature()) != null)
{
if ((feature.ShapeCopy == null) || (feature.ShapeCopy.IsEmpty))
{
continue;
}
IPoint p = feature.ShapeCopy as IPoint;
if (p.SpatialReference.FactoryCode != Helper.SpatialReferenceWGS84.FactoryCode)
{
p.Project(Helper.SpatialReferenceWGS84);
}
vector = new Vector(p.Y, p.X);
placemark = new Placemark();
placemark.Id = feature.OID.ToString();
placemark.Name = feature.OID.ToString();
extendedData = new ExtendedData();
foreach (int i in fields.Keys)
{
Data data = new Data();
data.DisplayName = fields[i];
data.Name = fields[i];
data.Value = feature.get_Value(i).ToString();
extendedData.AddData(data);
}
placemark.ExtendedData = extendedData;
placemark.Geometry = new SharpKml.Dom.Point {
Coordinate = vector
};
folder.AddFeature(placemark);
}
Kml kml = new Kml();
kml.AddNamespacePrefix(KmlNamespaces.GX22Prefix, KmlNamespaces.GX22Namespace);
kml.Feature = folder;
KmlFile kmlfile = KmlFile.Create(kml, false);
using (var stream = File.OpenWrite(System.IO.Path.Combine(targetPath, System.IO.Path.ChangeExtension(outputName, Enum.GetName(typeof(FileExtension), FileExtension.kmz)))))
{
kmlfile.Save(stream);
}
}
catch
{
throw;
}
finally
{
if (featureCursor != null)
{
Marshal.FinalReleaseComObject(featureCursor);
}
}
}
double ComputeHeadingFromPacks(int frameId, IEnumerable <BlobPack> packs, Image <Bgr, Byte> compass_frame, DebugState debugState)
{
var frame = Timeline.Data[frameId];
var my_extended = new ExtendedData();
frame.Heading.ForIndicatorUse = my_extended;
var choices = new List <Tuple <double, double, string, Image <Gray, byte> > >();
double unused_angle = 0;
var p = packs.OrderByDescending(px => px.BlobRationAngle);
foreach (var pack in packs)
{
var b = pack.BlobBox;
b.Inflate(2, 2);
var small_angle = pack.BlobRationAngle;
var str = ResolveTextFromPreviousFrame(frameId, small_angle);
if (string.IsNullOrWhiteSpace(str))
{
str = GetText(pack.BlobImage, debugState);
}
if (str == "N" || str == "E" || str == "S" || str == "W")
{
small_angle = 360 - Math.Abs(small_angle);
double new_heading = 0;
switch (str)
{
case "N":
my_extended.LastN = pack.BlobRationAngle;
new_heading = small_angle;
CvInvoke.Rectangle(compass_frame, b, new Bgr(Color.Blue).MCvScalar, 1);
break;
case "E":
my_extended.LastE = pack.BlobRationAngle;
new_heading = (small_angle + 90);
CvInvoke.Rectangle(compass_frame, b, new Bgr(Color.Yellow).MCvScalar, 1);
break;
case "S":
my_extended.LastS = pack.BlobRationAngle;
new_heading = (small_angle + 180);
CvInvoke.Rectangle(compass_frame, b, new Bgr(Color.Red).MCvScalar, 1);
break;
case "W":
my_extended.LastW = pack.BlobRationAngle;
new_heading = (small_angle + 270);
CvInvoke.Rectangle(compass_frame, b, new Bgr(Color.Lime).MCvScalar, 1);
break;
}
new_heading = Math2.ClampAngle(new_heading);
choices.Add(new Tuple <double, double, string, Image <Gray, byte> >(new_heading, small_angle, str, pack.BlobImage));
}
else
{
unused_angle = pack.BlobRationAngle;
}
}
// Fill in exactly one missing quadrant.
if (choices.Count == 3 && packs.Count() == 4)
{
var letters = new List <string>()
{
"N", "E", "S", "W"
};
foreach (var c in choices)
{
letters.Remove(c.Item3);
}
var o_angle = unused_angle;
unused_angle = 360 - Math.Abs(unused_angle);
double new_heading = 0;
var str = letters.First();
switch (str)
{
case "N":
my_extended.LastN = o_angle;
new_heading = unused_angle;
break;
case "E":
my_extended.LastE = o_angle;
new_heading = (unused_angle + 90);
break;
case "S":
my_extended.LastS = o_angle;
new_heading = (unused_angle + 180);
break;
case "W":
my_extended.LastW = o_angle;
new_heading = (unused_angle + 270);
break;
}
new_heading = Math2.ClampAngle(new_heading);
choices.Add(new Tuple <double, double, string, Image <Gray, byte> >(new_heading, (int)unused_angle, str, null));
}
if (choices.Count == 4)
{
// Exclude invalid combinations
if (choices.Where(ct => ct.Item3 == "N").Count() > 1)
{
debugState.SetError("Bad N");
return(double.NaN);
}
if (choices.Where(ct => ct.Item3 == "E").Count() > 1)
{
debugState.SetError("Bad E");
return(double.NaN);
}
if (choices.Where(ct => ct.Item3 == "S").Count() > 1)
{
debugState.SetError("Bad S");
return(double.NaN);
}
if (choices.Where(ct => ct.Item3 == "W").Count() > 1)
{
debugState.SetError("Bad W");
return(double.NaN);
}
var p1 = Math2.AddAngles(choices[0].Item1, choices[1].Item1);
var p2 = Math2.AddAngles(choices[2].Item1, choices[3].Item1);
return(Math2.AddAngles(p1, p2));
}
else
{
debugState.SetError($"Bad choices {choices.Count}");
}
return(double.NaN);
}
internal void AppendStackFrame(StringBuilder sb, string methodPrefix = "at ", bool appendNewLine = false, bool includeOffsets = false, bool includeColumn = false, bool linkFilePath = false, string traceIndentValue = " ")
{
if (!String.IsNullOrEmpty(traceIndentValue))
{
sb.Append(traceIndentValue);
}
if (!String.IsNullOrEmpty(methodPrefix))
{
sb.Append(methodPrefix);
}
if (String.IsNullOrEmpty(Name))
{
sb.Append("<null>");
if (appendNewLine)
{
sb.Append(Environment.NewLine);
}
return;
}
AppendMethod(sb);
if (includeOffsets && (ExtendedData.ContainsKey("ILOffset") || ExtendedData.ContainsKey("NativeOffset")))
{
sb.AppendFormat(" at offset {0}", ExtendedData["ILOffset"] ?? ExtendedData["NativeOffset"]);
}
if (!String.IsNullOrEmpty(FileName))
{
sb.Append(" in ");
if (!linkFilePath)
{
sb.Append(FileName);
}
else
{
Uri uri;
if (Uri.TryCreate(FileName, UriKind.Absolute, out uri))
{
sb.AppendFormat("<a href=\"").Append(uri.AbsoluteUri).Append("\" target=\"_blank\">").Append(FileName).Append("</a>");
}
else
{
sb.Append(FileName);
}
}
if (LineNumber > 0)
{
sb.Append(":line ").Append(LineNumber);
}
if (includeColumn && Column > 0)
{
sb.Append(":col ").Append(Column);
}
}
if (appendNewLine)
{
sb.Append(Environment.NewLine);
}
}
private Dictionary <string, string> ExtendedDataToDictionary(ExtendedData extendedData)
{
return((extendedData != null) ? extendedData.Data.ToDictionary(v => v.DisplayName, v => v.Value) : null);
}
