public LocationMonitorImpl(Accuracy accuracy)
{
DesiredAccuracy = accuracy;
}
/// <summary>
/// Initialize a new OCR Object.
///
/// This object is a wrapper for the Emgu Tesseract Wrapper to give a level of abstraction
/// necessary for scanning shreds
/// </summary>
/// <param name="accuracy"> Desired Accuracy setting </param>
/// <param name="language"> Language of text on image used for OCR model </param>
/// <param name="enableTimer"> Set enable Timer to true to measure scan time for diagnostic purposes </param>
public OCR(Accuracy accuracy = Accuracy.High, string language = "eng", bool enableTimer = false)
{
_timer = new Stopwatch();
if (enableTimer)
{
_timer.Start();
}
Tesseract.OcrEngineMode mode = Tesseract.OcrEngineMode.OEM_TESSERACT_CUBE_COMBINED;
switch (accuracy)
{
case Accuracy.Low:
mode = Tesseract.OcrEngineMode.OEM_TESSERACT_ONLY;
break;
case Accuracy.Medium:
mode = Tesseract.OcrEngineMode.OEM_CUBE_ONLY;
break;
case Accuracy.High:
mode = Tesseract.OcrEngineMode.OEM_TESSERACT_CUBE_COMBINED;
break;
}
_tesseract = new Tesseract("tessdata", language, mode);
//"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
_tesseract.SetVariable("tessedit_unrej_any_wd", "T");
//_tesseract.SetVariable("tessedit_char_whitelist","abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWZ0123456789.,");
_text = null;
_chars = null;
_confidence = -1;
}
public void TestData()
{
var trainingData = ReadTestData("../../../../Data/train_sensor.txt", "../../../../Data/train_category.txt");
var floatPrecision = 50;
var cl = Create();
foreach (var frame in trainingData)
{
var bits = AsBitArray(BitMapper.Map(frame.Columns, -0.6f, 2.21f, floatPrecision), frame.Columns.Length * floatPrecision);
cl.Train(frame.Category.ToString(), bits);
}
var testData = ReadTestData("../../../../Data/test_sensor.txt", "../../../../Data/test_category.txt");
var acurate = 0;
var total = 0;
var accuracy = new Dictionary<string, Accuracy>();
foreach (var frame in testData)
{
var bits = AsBitArray(BitMapper.Map(frame.Columns, -0.6f, 2.21f, floatPrecision), frame.Columns.Length * floatPrecision);
var matches = cl.FindMatches(bits)
.OrderByDescending(c => c.Strength)
.Take(2)
.ToArray();
var cat = frame.Category.ToString();
if (matches[0].Identifier == cat) acurate++;
total++;
Accuracy v;
if (!accuracy.TryGetValue(cat, out v))
accuracy.Add(cat, v = new Accuracy());
if (matches[0].Identifier == frame.Category.ToString()) v.acurate++;
v.total++;
Console.WriteLine("Expected: {0} Matched: {1} ({3:p}) Runner Up: {2} ({4:p})", frame.Category, matches[0].Identifier, matches[1].Identifier, matches[0].Strength, matches[1].Strength);
}
Console.WriteLine("Accuracy: {0:p}", ((float)acurate) / ((float)total));
foreach (var pair in accuracy)
Console.WriteLine("Accuracy {1}: {0:p}", ((float)pair.Value.acurate) / ((float)pair.Value.total), pair.Key);
}
public override void WriteTo(ArcXmlWriter writer)
{
try
{
writer.WriteStartElement(XmlName);
if (Accuracy > 0)
{
writer.WriteAttributeString("accuracy", Accuracy.ToString());
}
if (FeatureLimit > 0)
{
writer.WriteAttributeString("featurelimit", FeatureLimit.ToString());
}
if (!String.IsNullOrEmpty(JoinExpression))
{
writer.WriteAttributeString("joinexpression", JoinExpression);
}
if (!String.IsNullOrEmpty(JoinTables))
{
writer.WriteAttributeString("jointables", JoinTables);
}
if (!String.IsNullOrEmpty(OrderBy))
{
writer.WriteAttributeString("order_by", OrderBy);
}
if (!String.IsNullOrEmpty(Subfields))
{
writer.WriteAttributeString("subfields", Subfields);
}
if (!String.IsNullOrEmpty(Where))
{
writer.WriteAttributeString("where", Where);
}
if (Buffer != null)
{
Buffer.WriteTo(writer);
}
if (FeatureCoordSys != null)
{
FeatureCoordSys.WriteTo(writer);
}
if (FilterCoordSys != null)
{
FilterCoordSys.WriteTo(writer);
}
if (SpatialFilter != null)
{
SpatialFilter.WriteTo(writer);
}
writer.WriteEndElement();
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not write {0} object.", GetType().Name), ex);
}
}
}
/// <summary>
/// Takes the various properties of this instance and adds them to a <see cref="Dictionary{K,V}"/> instanced passed in, ready for sending to Flickr.
/// </summary>
/// <param name="parameters">The <see cref="Dictionary{K,V}"/> to add the options to.</param>
public void AddToDictionary(Dictionary <string, string> parameters)
{
if (!string.IsNullOrEmpty(UserId))
{
parameters.Add("user_id", UserId);
}
if (!string.IsNullOrEmpty(GroupId))
{
parameters.Add("group_id", GroupId);
}
if (!string.IsNullOrEmpty(Text))
{
parameters.Add("text", Text);
}
if (!string.IsNullOrEmpty(Tags))
{
parameters.Add("tags", Tags);
}
if (TagMode != TagMode.None)
{
parameters.Add("tag_mode", UtilityMethods.TagModeToString(TagMode));
}
if (!string.IsNullOrEmpty(MachineTags))
{
parameters.Add("machine_tags", MachineTags);
}
if (MachineTagMode != MachineTagMode.None)
{
parameters.Add("machine_tag_mode", UtilityMethods.MachineTagModeToString(MachineTagMode));
}
if (MinUploadDate != DateTime.MinValue)
{
parameters.Add("min_upload_date", UtilityMethods.DateToUnixTimestamp(MinUploadDate).ToString());
}
if (MaxUploadDate != DateTime.MinValue)
{
parameters.Add("max_upload_date", UtilityMethods.DateToUnixTimestamp(MaxUploadDate).ToString());
}
if (MinTakenDate != DateTime.MinValue)
{
parameters.Add("min_taken_date", UtilityMethods.DateToMySql(MinTakenDate));
}
if (MaxTakenDate != DateTime.MinValue)
{
parameters.Add("max_taken_date", UtilityMethods.DateToMySql(MaxTakenDate));
}
if (Licenses.Count != 0)
{
var licenseArray = new List <string>();
foreach (var license in Licenses)
{
licenseArray.Add(license.ToString("d"));
}
parameters.Add("license", string.Join(",", licenseArray.ToArray()));
}
if (PerPage != 0)
{
parameters.Add("per_page", PerPage.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (Page != 0)
{
parameters.Add("page", Page.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (Extras != PhotoSearchExtras.None)
{
parameters.Add("extras", ExtrasString);
}
if (SortOrder != PhotoSearchSortOrder.None)
{
parameters.Add("sort", SortOrderString);
}
if (PrivacyFilter != PrivacyFilter.None)
{
parameters.Add("privacy_filter", PrivacyFilter.ToString("d"));
}
if (BoundaryBox != null && BoundaryBox.IsSet)
{
parameters.Add("bbox", BoundaryBox.ToString());
}
if (Accuracy != GeoAccuracy.None)
{
parameters.Add("accuracy", Accuracy.ToString("d"));
}
if (SafeSearch != SafetyLevel.None)
{
parameters.Add("safe_search", SafeSearch.ToString("d"));
}
if (ContentType != ContentTypeSearch.None)
{
parameters.Add("content_type", ContentType.ToString("d"));
}
if (HasGeo != null)
{
parameters.Add("has_geo", HasGeo.Value ? "1" : "0");
}
if (Latitude != null)
{
parameters.Add("lat", Latitude.Value.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (Longitude != null)
{
parameters.Add("lon", Longitude.Value.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (Radius != null)
{
parameters.Add("radius", Radius.Value.ToString("0.00000", System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (RadiusUnits != RadiusUnit.None)
{
parameters.Add("radius_units", (RadiusUnits == RadiusUnit.Miles ? "mi" : "km"));
}
if (Contacts != ContactSearch.None)
{
parameters.Add("contacts", (Contacts == ContactSearch.AllContacts ? "all" : "ff"));
}
if (WoeId != null)
{
parameters.Add("woe_id", WoeId);
}
if (PlaceId != null)
{
parameters.Add("place_id", PlaceId);
}
if (IsCommons)
{
parameters.Add("is_commons", "1");
}
if (InGallery)
{
parameters.Add("in_gallery", "1");
}
if (IsGetty)
{
parameters.Add("is_getty", "1");
}
if (MediaType != MediaType.None)
{
parameters.Add("media", UtilityMethods.MediaTypeToString(MediaType));
}
if (GeoContext != GeoContext.NotDefined)
{
parameters.Add("geo_context", GeoContext.ToString("d"));
}
if (Faves)
{
parameters.Add("faves", "1");
}
if (PersonId != null)
{
parameters.Add("person_id", PersonId);
}
if (Camera != null)
{
parameters.Add("camera", Camera);
}
if (JumpTo != null)
{
parameters.Add("jump_to", JumpTo);
}
if (!string.IsNullOrEmpty(Username))
{
parameters.Add("username", Username);
}
if (ExifMinExposure != null)
{
parameters.Add("exif_min_exposure", ExifMinExposure.Value.ToString("0.00000", System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (ExifMaxExposure != null)
{
parameters.Add("exif_max_exposure", ExifMaxExposure.Value.ToString("0.00000", System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (ExifMinAperture != null)
{
parameters.Add("exif_min_aperture", ExifMinAperture.Value.ToString("0.00000", System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (ExifMaxAperture != null)
{
parameters.Add("exif_max_aperture", ExifMaxAperture.Value.ToString("0.00000", System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (ExifMinFocalLength != null)
{
parameters.Add("exif_min_focallen", ExifMinFocalLength.Value.ToString("0", System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (ExifMaxFocalLength != null)
{
parameters.Add("exif_max_focallen", ExifMaxFocalLength.Value.ToString("0", System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (ExcludeUserID != null)
{
parameters.Add("exclude_user_id", ExcludeUserID);
}
if (FoursquareVenueID != null)
{
parameters.Add("foursquare_venueid", FoursquareVenueID);
}
if (FoursquareWoeID != null)
{
parameters.Add("foursquare_woeid", FoursquareWoeID);
}
if (GroupPathAlias != null)
{
parameters.Add("group_path_alias", GroupPathAlias);
}
if (ColorCodes != null && ColorCodes.Count != 0)
{
parameters.Add("color_codes", ColorCodeString);
}
}
public async Task <IActionResult> PostSubmitModular()
{
string score = Request.Form["score"];
string iv = Request.Form["iv"];
string osuver = Request.Form["osuver"];
string pass = Request.Form["pass"];
var(b, scores) = ScoreSubmissionParser.ParseScore(_factory, score, iv, osuver);
if (scores.UserId == -1)
{
return(Ok("error: pass"));
}
if (scores.ScoreOwner == null)
{
scores.ScoreOwner = Users.GetUser(_factory, scores.UserId);
}
if (scores.ScoreOwner == null)
{
return(Ok("error: pass"));
}
if (!scores.ScoreOwner.IsPassword(pass))
{
return(Ok("error: pass"));
}
var isRelaxing = (scores.Mods & Mod.Relax) != 0;
var pr = _ps.GetPresence(scores.ScoreOwner.Id);
if (!b || !RankedMods.IsRanked(scores.Mods))
{
if (isRelaxing)
{
var rx = LeaderboardRx.GetLeaderboard(_factory, scores.ScoreOwner);
rx.IncreasePlaycount(_factory, scores.PlayMode);
rx.IncreaseScore(_factory, (ulong)scores.TotalScore, false, scores.PlayMode);
}
else
{
var std = LeaderboardStd.GetLeaderboard(_factory, scores.ScoreOwner);
std.IncreasePlaycount(_factory, scores.PlayMode);
std.IncreaseScore(_factory, (ulong)scores.TotalScore, false, scores.PlayMode);
}
await _ev.RunEvent(
EventType.BanchoUserStatsRequest,
new BanchoUserStatsRequestArgs { userIds = new List <int> {
scores.ScoreOwner.Id
}, pr = pr }
);
return(Ok("Thanks for your hard work!"));
}
/*
* switch (scores.PlayMode)
* {
* case PlayMode.Osu:
* oppai op = new oppai(BeatmapDownloader.GetBeatmap(scores.FileMd5, _config));
* op.SetAcc((int) scores.Count300, (int) scores.Count50, (int) scores.CountMiss);
* op.SetCombo(scores.MaxCombo);
* op.SetMods(scores.Mods);
* op.Calculate();
*
* scores.PeppyPoints = op.GetPP();
* Logger.Info("Peppy Points:", scores.PeppyPoints);
* break;
* }
*/
var ReplayFile = Request.Form.Files.GetFile("score");
if (!Directory.Exists("data/replays"))
{
Directory.CreateDirectory("data/replays");
}
await using (var m = new MemoryStream())
{
ReplayFile.CopyTo(m);
m.Position = 0;
scores.ReplayMd5 = Hex.ToHex(Crypto.GetMd5(m)) ?? string.Empty;
if (!string.IsNullOrEmpty(scores.ReplayMd5))
{
await using (var replayFile = System.IO.File.Create($"data/replays/{scores.ReplayMd5}"))
{
m.Position = 0;
m.WriteTo(replayFile);
m.Close();
replayFile.Close();
}
}
}
BeatmapDownloader.GetBeatmap(scores.FileMd5, _config);
if (isRelaxing)
{
scores.Mods -= Mod.Relax;
}
scores.PeppyPoints = PerformancePointsProcessor.Compute(scores);
if (isRelaxing)
{
scores.Mods |= Mod.Relax;
}
var oldScore = Scores.GetScores(
_factory,
scores.FileMd5,
scores.ScoreOwner,
scores.PlayMode,
isRelaxing,
false,
false,
false,
scores.Mods,
true
).FirstOrDefault();
var oldStd = LeaderboardStd.GetLeaderboard(_factory, scores.ScoreOwner);
var oldStdPos = oldStd.GetPosition(_factory, scores.PlayMode);
if (oldScore != null && oldScore.TotalScore <= scores.TotalScore)
{
using var db = _factory.GetForWrite();
db.Context.Scores.Remove(oldScore);
System.IO.File.Delete($"data/replays/{oldScore.ReplayMd5}");
Scores.InsertScore(_factory, scores);
}
else if (oldScore == null)
{
Scores.InsertScore(_factory, scores);
}
else
{
System.IO.File.Delete($"data/replays/{scores.ReplayMd5}");
}
if (isRelaxing)
{
var rx = LeaderboardRx.GetLeaderboard(_factory, scores.ScoreOwner);
rx.IncreasePlaycount(_factory, scores.PlayMode);
rx.IncreaseCount300(_factory, scores.Count300, scores.PlayMode);
rx.IncreaseCount100(_factory, scores.Count100, scores.PlayMode);
rx.IncreaseCount50(_factory, scores.Count50, scores.PlayMode);
rx.IncreaseCountMiss(_factory, scores.CountMiss, scores.PlayMode);
rx.IncreaseScore(_factory, (ulong)scores.TotalScore, true, scores.PlayMode);
rx.IncreaseScore(_factory, (ulong)scores.TotalScore, false, scores.PlayMode);
rx.UpdatePP(_factory, scores.PlayMode);
pr.LeaderboardRx = rx;
await _ev.RunEvent(
EventType.BanchoUserStatsRequest,
new BanchoUserStatsRequestArgs { userIds = new List <int> {
scores.ScoreOwner.Id
}, pr = pr }
);
}
else
{
var std = LeaderboardStd.GetLeaderboard(_factory, scores.ScoreOwner);
std.IncreasePlaycount(_factory, scores.PlayMode);
std.IncreaseCount300(_factory, scores.Count300, scores.PlayMode);
std.IncreaseCount100(_factory, scores.Count100, scores.PlayMode);
std.IncreaseCount50(_factory, scores.Count50, scores.PlayMode);
std.IncreaseCountMiss(_factory, scores.CountMiss, scores.PlayMode);
std.IncreaseScore(_factory, (ulong)scores.TotalScore, true, scores.PlayMode);
std.IncreaseScore(_factory, (ulong)scores.TotalScore, false, scores.PlayMode);
std.UpdatePP(_factory, scores.PlayMode);
}
var newStd = LeaderboardStd.GetLeaderboard(_factory, scores.ScoreOwner);
var newStdPos = newStd.GetPosition(_factory, scores.PlayMode);
var NewScore = Scores.GetScores(
_factory,
scores.FileMd5,
scores.ScoreOwner,
scores.PlayMode,
isRelaxing,
false,
false,
false,
scores.Mods,
true
).FirstOrDefault();
var cg = new Cheesegull(_config);
cg.SetBM(scores.FileMd5);
var sets = cg.GetSets();
var bm = sets?[0].ChildrenBeatmaps.First(x => x.FileMD5 == scores.FileMd5) ?? new CheesegullBeatmap();
double oldAcc;
double newAcc;
ulong oldRankedScore;
ulong newRankedScore;
double oldPP;
double newPP;
switch (scores.PlayMode)
{
case PlayMode.Osu:
oldAcc = Accuracy.GetAccuracy(
oldStd.Count300Osu,
oldStd.Count100Osu,
oldStd.Count50Osu,
oldStd.Count300Osu, 0, 0,
PlayMode.Osu
);
newAcc = Accuracy.GetAccuracy(
newStd.Count300Osu,
newStd.Count100Osu,
newStd.Count50Osu,
newStd.Count300Osu, 0, 0,
PlayMode.Osu
);
oldRankedScore = oldStd.RankedScoreOsu;
newRankedScore = newStd.RankedScoreOsu;
oldPP = oldStd.PerformancePointsOsu;
newPP = newStd.PerformancePointsOsu;
break;
case PlayMode.Taiko:
oldAcc = Accuracy.GetAccuracy(
oldStd.Count300Taiko,
oldStd.Count100Taiko,
oldStd.Count50Taiko,
oldStd.Count300Taiko, 0, 0,
PlayMode.Taiko
);
newAcc = Accuracy.GetAccuracy(
newStd.Count300Taiko,
newStd.Count100Taiko,
newStd.Count50Taiko,
newStd.Count300Taiko, 0, 0,
PlayMode.Taiko
);
oldRankedScore = oldStd.RankedScoreTaiko;
newRankedScore = newStd.RankedScoreTaiko;
oldPP = oldStd.PerformancePointsTaiko;
newPP = newStd.PerformancePointsTaiko;
break;
case PlayMode.Ctb:
oldAcc = Accuracy.GetAccuracy(
oldStd.Count300Ctb,
oldStd.Count100Ctb,
oldStd.Count50Ctb,
oldStd.Count300Ctb, 0, 0,
PlayMode.Ctb
);
newAcc = Accuracy.GetAccuracy(
newStd.Count300Ctb,
newStd.Count100Ctb,
newStd.Count50Ctb,
newStd.Count300Ctb, 0, 0,
PlayMode.Ctb
);
oldRankedScore = oldStd.RankedScoreCtb;
newRankedScore = newStd.RankedScoreCtb;
oldPP = oldStd.PerformancePointsCtb;
newPP = newStd.PerformancePointsCtb;
break;
case PlayMode.Mania:
oldAcc = Accuracy.GetAccuracy(
oldStd.Count300Mania,
oldStd.Count100Mania,
oldStd.Count50Mania,
oldStd.Count300Mania, 0, 0,
PlayMode.Mania
);
newAcc = Accuracy.GetAccuracy(
newStd.Count300Mania,
newStd.Count100Mania,
newStd.Count50Mania,
newStd.Count300Mania, 0, 0,
PlayMode.Mania
);
oldRankedScore = oldStd.RankedScoreMania;
newRankedScore = newStd.RankedScoreMania;
oldPP = oldStd.PerformancePointsMania;
newPP = newStd.PerformancePointsMania;
break;
default:
return(Ok(""));
}
if (NewScore?.Position == 1 && (oldScore == null || oldScore.TotalScore < NewScore.TotalScore))
{
_sora.SendMessage(
$"[http://{_config.Server.Hostname}/{scores.ScoreOwner.Id} {scores.ScoreOwner.Username}] " +
$"has reached #1 on [https://osu.ppy.sh/b/{bm.BeatmapID} {sets?[0].Title} [{bm.DiffName}]] " +
$"using {ModUtil.ToString(NewScore.Mods)} " +
$"Good job! +{NewScore.PeppyPoints:F}PP",
"#announce",
false
);
}
Logger.Info(
$"{L_COL.RED}{scores.ScoreOwner.Username}",
$"{L_COL.PURPLE}( {scores.ScoreOwner.Id} ){L_COL.WHITE}",
$"has just submitted a Score! he earned {L_COL.BLUE}{NewScore?.PeppyPoints:F}PP",
$"{L_COL.WHITE}with an Accuracy of {L_COL.RED}{NewScore?.Accuracy * 100:F}",
$"{L_COL.WHITE}on {L_COL.YELLOW}{sets?[0].Title} [{bm.DiffName}]",
$"{L_COL.WHITE}using {L_COL.BLUE}{ModUtil.ToString(NewScore?.Mods ?? Mod.None)}"
);
var bmChart = new Chart(
"beatmap",
"Beatmap Ranking",
$"https://osu.ppy.sh/b/{bm.BeatmapID}",
oldScore?.Position ?? 0,
NewScore?.Position ?? 0,
oldScore?.MaxCombo ?? 0,
NewScore?.MaxCombo ?? 0,
oldScore?.Accuracy * 100 ?? 0,
NewScore?.Accuracy * 100 ?? 0,
(ulong)(oldScore?.TotalScore ?? 0),
(ulong)(NewScore?.TotalScore ?? 0),
oldScore?.PeppyPoints ?? 0,
NewScore?.PeppyPoints ?? 0,
NewScore?.Id ?? 0
);
cg.SetBMSet(bm.ParentSetID);
var overallChart = new Chart(
"overall",
"Global Ranking",
$"https://osu.ppy.sh/u/{scores.ScoreOwner.Id}",
(int)oldStdPos,
(int)newStdPos,
0,
0,
oldAcc * 100,
newAcc * 100,
oldRankedScore,
newRankedScore,
oldPP,
newPP,
NewScore?.Id ?? 0,
AchievementProcessor.ProcessAchievements(
_factory, scores.ScoreOwner, scores, bm, cg.GetSets()[0], oldStd, newStd
)
);
pr.LeaderboardStd = newStd;
await _ev.RunEvent(
EventType.BanchoUserStatsRequest,
new BanchoUserStatsRequestArgs { userIds = new List <int> {
scores.ScoreOwner.Id
}, pr = pr }
);
return(Ok(
$"beatmapId:{bm.BeatmapID}|beatmapSetId:{bm.ParentSetID}|beatmapPlaycount:0|beatmapPasscount:0|approvedDate:\n\n" +
bmChart.ToOsuString() + "\n" + overallChart.ToOsuString()
));
}
public override int GetHashCode()
{
var hashCode = -1002157333;
hashCode = hashCode * -1521134295 + Index.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(FullName);
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(GroupName);
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(SetName);
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(Name);
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(Display);
hashCode = hashCode * -1521134295 + Available.GetHashCode();
hashCode = hashCode * -1521134295 + ModesRequired.GetHashCode();
hashCode = hashCode * -1521134295 + ModesDisallowed.GetHashCode();
hashCode = hashCode * -1521134295 + PowerType.GetHashCode();
hashCode = hashCode * -1521134295 + Accuracy.GetHashCode();
hashCode = hashCode * -1521134295 + AttackTypes.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string[]> .Default.GetHashCode(GroupMemberships);
hashCode = hashCode * -1521134295 + EntitiesAffected.GetHashCode();
hashCode = hashCode * -1521134295 + EntitiesAutoHit.GetHashCode();
hashCode = hashCode * -1521134295 + Target.GetHashCode();
hashCode = hashCode * -1521134295 + TargetLineOfSight.GetHashCode();
hashCode = hashCode * -1521134295 + Range.GetHashCode();
hashCode = hashCode * -1521134295 + TargetSecondary.GetHashCode();
hashCode = hashCode * -1521134295 + RangeSecondary.GetHashCode();
hashCode = hashCode * -1521134295 + EnduranceCost.GetHashCode();
hashCode = hashCode * -1521134295 + InterruptTime.GetHashCode();
hashCode = hashCode * -1521134295 + CastTime.GetHashCode();
hashCode = hashCode * -1521134295 + RechargeTime.GetHashCode();
hashCode = hashCode * -1521134295 + BaseRechargeTime.GetHashCode();
hashCode = hashCode * -1521134295 + ActivatePeriod.GetHashCode();
hashCode = hashCode * -1521134295 + EffectArea.GetHashCode();
hashCode = hashCode * -1521134295 + Radius.GetHashCode();
hashCode = hashCode * -1521134295 + Arc.GetHashCode();
hashCode = hashCode * -1521134295 + MaxTargets.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(MaxBoosts);
hashCode = hashCode * -1521134295 + CastFlags.GetHashCode();
hashCode = hashCode * -1521134295 + ArtificalIntelligenceReport.GetHashCode();
hashCode = hashCode * -1521134295 + NumberOfCharges.GetHashCode();
hashCode = hashCode * -1521134295 + UsageTime.GetHashCode();
hashCode = hashCode * -1521134295 + LifeTime.GetHashCode();
hashCode = hashCode * -1521134295 + LifeTimeInGame.GetHashCode();
hashCode = hashCode * -1521134295 + NumberAllowed.GetHashCode();
hashCode = hashCode * -1521134295 + DoNotSave.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string[]> .Default.GetHashCode(BoostsAllowed);
hashCode = hashCode * -1521134295 + CastThroughHold.GetHashCode();
hashCode = hashCode * -1521134295 + IgnoreStrength.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(DescriptionShort);
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(DescriptionLong);
hashCode = hashCode * -1521134295 + EqualityComparer <int[]> .Default.GetHashCode(SetTypes);
hashCode = hashCode * -1521134295 + ClickBuff.GetHashCode();
hashCode = hashCode * -1521134295 + AlwaysToggle.GetHashCode();
hashCode = hashCode * -1521134295 + Level.GetHashCode();
hashCode = hashCode * -1521134295 + AllowFrontLoading.GetHashCode();
hashCode = hashCode * -1521134295 + VariableEnabled.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(VariableName);
hashCode = hashCode * -1521134295 + VariableMin.GetHashCode();
hashCode = hashCode * -1521134295 + VariableMax.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string[]> .Default.GetHashCode(SubPowers);
hashCode = hashCode * -1521134295 + EqualityComparer <int[]> .Default.GetHashCode(IgnoreEnhancements);
hashCode = hashCode * -1521134295 + EqualityComparer <int[]> .Default.GetHashCode(IgnoreBuffs);
hashCode = hashCode * -1521134295 + SkipMax.GetHashCode();
hashCode = hashCode * -1521134295 + DisplayLocation.GetHashCode();
hashCode = hashCode * -1521134295 + MutuallyExclusiveAuto.GetHashCode();
hashCode = hashCode * -1521134295 + MutuallyExclusiveIgnore.GetHashCode();
hashCode = hashCode * -1521134295 + AbsorbSummonEffects.GetHashCode();
hashCode = hashCode * -1521134295 + AbsorbSummonAttributes.GetHashCode();
hashCode = hashCode * -1521134295 + ShowSummonAnyway.GetHashCode();
hashCode = hashCode * -1521134295 + NeverAutoUpdate.GetHashCode();
hashCode = hashCode * -1521134295 + NeverAutoUpdateRequirements.GetHashCode();
hashCode = hashCode * -1521134295 + IncludeFlag.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(ForcedClass);
hashCode = hashCode * -1521134295 + SortOverride.GetHashCode();
hashCode = hashCode * -1521134295 + BoostBoostable.GetHashCode();
hashCode = hashCode * -1521134295 + BoostUsePlayerLevel.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <Effect[]> .Default.GetHashCode(Effects);
hashCode = hashCode * -1521134295 + HiddenPower.GetHashCode();
return(hashCode);
}
public void Read_WithInvalidAsn1_Throws()
{
Assert.Throws <CryptographicException>(
() => Accuracy.Read(new byte[] { 0x30, 0x0b }));
}
public RegularTimeFormatter(Accuracy accuracy = Accuracy.Seconds)
{
this.Accuracy = accuracy;
}
public static void RunSimple()
{
var mnist = TestUtils.GetMNIST(); //Get the MNIST dataset, it will download if not found
var batch_size = 100; //Set training batch size
var train_data = new NDArrayIter(mnist["train_data"], mnist["train_label"], batch_size, true);
var val_data = new NDArrayIter(mnist["test_data"], mnist["test_label"], batch_size);
// Define simple network with dense layers
var net = new Sequential();
net.Add(new Dense(128, ActivationType.Relu, in_units: 784));
net.Add(new Dense(64, ActivationType.Relu, in_units: 128));
net.Add(new Dense(10, in_units: 64));
//Set context, multi-gpu supported
var gpus = TestUtils.ListGpus();
var ctx = gpus.Count > 0 ? gpus.Select(x => Context.Gpu(x)).ToArray() : new[] { Context.Cpu(0) };
//Initialize the weights
net.Initialize(new Xavier(magnitude: 2.24f), ctx);
//Create the trainer with all the network parameters and set the optimizer
var trainer = new Trainer(net.CollectParams(), new SGD(learning_rate: 0.1f));
var epoch = 100;
var metric = new Accuracy(); //Use Accuracy as the evaluation metric.
var softmax_cross_entropy_loss = new SoftmaxCrossEntropyLoss();
float lossVal = 0; //For loss calculation
for (var iter = 0; iter < epoch; iter++)
{
var tic = DateTime.Now;
// Reset the train data iterator.
train_data.Reset();
lossVal = 0;
// Loop over the train data iterator.
while (!train_data.End())
{
var batch = train_data.Next();
// Splits train data into multiple slices along batch_axis
// and copy each slice into a context.
var data = Utils.SplitAndLoad(batch.Data[0], ctx, batch_axis: 0);
// Splits train labels into multiple slices along batch_axis
// and copy each slice into a context.
var label = Utils.SplitAndLoad(batch.Label[0], ctx, batch_axis: 0);
var outputs = new NDArrayList();
// Inside training scope
NDArray loss = null;
for (int i = 0; i < data.Length; i++)
{
using (var ag = Autograd.Record())
{
var x = data[i];
var y = label[i];
var z = net.Call(x);
loss = softmax_cross_entropy_loss.Call(z, y);
outputs.Add(z);
}
// Computes softmax cross entropy loss.
// Backpropagate the error for one iteration.
loss.Backward();
lossVal += loss.Mean();
}
//outputs = Enumerable.Zip(data, label, (x, y) =>
//{
// var z = net.Call(x);
// // Computes softmax cross entropy loss.
// NDArray loss = softmax_cross_entropy_loss.Call(z, y);
// // Backpropagate the error for one iteration.
// loss.Backward();
// lossVal += loss.Mean();
// return z;
//}).ToList();
// Updates internal evaluation
metric.Update(label, outputs.ToArray());
// Make one step of parameter update. Trainer needs to know the
// batch size of data to normalize the gradient by 1/batch_size.
trainer.Step(batch.Data[0].Shape[0]);
}
var toc = DateTime.Now;
// Gets the evaluation result.
var(name, acc) = metric.Get();
// Reset evaluation result to initial state.
metric.Reset();
Console.Write($"Loss: {lossVal} ");
Console.WriteLine($"Training acc at epoch {iter}: {name}={(acc * 100).ToString("0.##")}%, Duration: {(toc - tic).TotalSeconds.ToString("0.#")}s");
}
}
protected override void OnExecute(Command command, ExecutionContext context, System.Drawing.Rectangle buttonRect)
{
double lengthConversion = ActiveWindow.Units.Length.ConversionFactor;
int numberOfTeethL = (int)Values[Resources.NumberOfTeethLText].Value;
int numberOfTeethR = (int)Values[Resources.NumberOfTeethRText].Value;
bool isInternalL = numberOfTeethL < 0;
bool isInternalR = numberOfTeethR < 0;
numberOfTeethL = Math.Abs(numberOfTeethL);
numberOfTeethR = Math.Abs(numberOfTeethR);
double pressureAngle = Values[Resources.PressureAngleText].Value * Math.PI / 180;
double module = Values[Resources.ModuleText].Value / lengthConversion;
double dedendumClearance = Values[Resources.DedendumClearanceText].Value;
double depth = Values[Resources.DepthText].Value / lengthConversion;
bool useTrochoidalInterferenceRemoval = Booleans[Resources.UseTrochoidalText].Value;
bool addDedendumClearance = Booleans[Resources.AddDedendumClearance].Value;
if (!addDedendumClearance)
{
dedendumClearance = 0;
}
bool isBevel = RibbonBooleanGroupCapsule.BooleanGroupCapsules[Resources.IsBevelText].IsEnabledCommandBoolean.Value;
double bevelAngle = RibbonBooleanGroupCapsule.BooleanGroupCapsules[Resources.IsBevelText].Values[Resources.BevelAngleText].Value * Math.PI / 180;
double bevelKneeRatio = RibbonBooleanGroupCapsule.BooleanGroupCapsules[Resources.IsBevelText].Values[Resources.BevelKneeRatioText].Value;
bool isHelical = RibbonBooleanGroupCapsule.BooleanGroupCapsules[Resources.IsHelicalText].IsEnabledCommandBoolean.Value;
double helicalAngle = RibbonBooleanGroupCapsule.BooleanGroupCapsules[Resources.IsHelicalText].Values[Resources.HelicalAngleText].Value * Math.PI / 180;
if (!isHelical)
{
helicalAngle = 0;
}
bool isScrew = RibbonBooleanGroupCapsule.BooleanGroupCapsules[Resources.IsScrewText].IsEnabledCommandBoolean.Value;
double screwAngle = RibbonBooleanGroupCapsule.BooleanGroupCapsules[Resources.IsScrewText].Values[Resources.ScrewAngleText].Value * Math.PI / 180;
double screwAngleOffset = RibbonBooleanGroupCapsule.BooleanGroupCapsules[Resources.IsScrewText].Values[Resources.ScrewAngleBiasText].Value * Math.PI / 180;
if (!isScrew)
{
screwAngle = 0;
screwAngleOffset = 0;
}
double screwAngleAverage = screwAngle / 2;
double screwAngleL = screwAngleAverage + screwAngleOffset;
double screwAngleR = screwAngleAverage - screwAngleOffset;
bool isHypoid = RibbonBooleanGroupCapsule.BooleanGroupCapsules[Resources.IsHypoidText].IsEnabledCommandBoolean.Value;
double hypoidAngle = RibbonBooleanGroupCapsule.BooleanGroupCapsules[Resources.IsHypoidText].Values[Resources.HypoidAngleText].Value * Math.PI / 180;
double hypoidOffset = RibbonBooleanGroupCapsule.BooleanGroupCapsules[Resources.IsHypoidText].Values[Resources.HypoidOffsetText].Value / lengthConversion;
if (!isHypoid)
{
hypoidAngle = 0;
hypoidOffset = 0;
}
Frame frame = Frame.World;
//Circle circle = SelectedCircle(ActiveWindow);
//if (circle != null)
// frame = circle.Frame;
List <ITrimmedCurve> selectedCurves = ActiveWindow.GetAllSelectedITrimmedCurves().ToList();
if (selectedCurves.Count == 2 && selectedCurves[0].Geometry is Circle && selectedCurves[0].Geometry is Circle)
{
Circle circle0 = (Circle)selectedCurves[0].Geometry;
Circle circle1 = (Circle)selectedCurves[1].Geometry;
Separation separation = circle0.Axis.GetClosestSeparation(circle1.Axis);
if (Accuracy.LengthIsZero(separation.Distance))
{
throw new NotImplementedException("Distance between axes is zero; only hypoid implemented.");
}
isHypoid = true;
hypoidAngle = AddInHelper.AngleBetween(circle0.Axis.Direction, circle1.Axis.Direction);
hypoidOffset = ((circle0.Frame.Origin - separation.PointA).Magnitude - depth / 2) / Math.Cos(hypoidAngle / 2);
double radiusAApprox = separation.Distance * circle0.Radius / (circle0.Radius + circle1.Radius);
double radiusBApprox = separation.Distance - radiusAApprox;
numberOfTeethR = (int)Math.Round((double)numberOfTeethL / radiusAApprox * radiusBApprox);
module = radiusAApprox * 2 / numberOfTeethL;
Point midpoint = separation.PointA + (separation.PointA - separation.PointB) * numberOfTeethL / numberOfTeethR;
Direction sideSide = (circle0.Frame.Origin - circle1.Frame.Origin).Direction;
frame = Frame.Create(midpoint, Direction.Cross(sideSide, -(midpoint - circle0.GetClosestSeparation(circle1).PointA).Direction), sideSide);
}
double hypoidAngleL = Math.Atan(Math.Sin(hypoidAngle) / (Math.Cos(hypoidAngle) + (double)numberOfTeethR / numberOfTeethL));
double hypoidAngleR = Math.Atan(Math.Sin(hypoidAngle) / (Math.Cos(hypoidAngle) + (double)numberOfTeethL / numberOfTeethR));
Gear gearL = null;
Gear gearR = null;
var gearDataL = new GearData(numberOfTeethL, pressureAngle, module, dedendumClearance, isInternalL, screwAngleL);
var gearDataR = new GearData(numberOfTeethR, pressureAngle, module, dedendumClearance, isInternalR, screwAngleR);
ToothProfile toothProfileL = GetGearProfileFromOptions(gearDataL, gearDataR, useTrochoidalInterferenceRemoval, addDedendumClearance);
ToothProfile toothProfileR = GetGearProfileFromOptions(gearDataR, gearDataL, useTrochoidalInterferenceRemoval, addDedendumClearance);
if (isBevel)
{
gearL = BevelGear.Create(ActiveIPart, gearDataL, gearDataR, toothProfileL, helicalAngle, bevelAngle, bevelKneeRatio, depth);
gearR = BevelGear.Create(ActiveIPart, gearDataR, gearDataL, toothProfileR, -helicalAngle, bevelAngle, bevelKneeRatio, depth);
}
else if (isHypoid)
{
gearL = HypoidGear.Create(ActiveIPart, gearDataL, gearDataR, toothProfileL, helicalAngle, hypoidAngleL, hypoidOffset, bevelKneeRatio, depth);
gearR = HypoidGear.Create(ActiveIPart, gearDataR, gearDataL, toothProfileR, -helicalAngle, hypoidAngleR, hypoidOffset, bevelKneeRatio, depth);
}
else
{
gearL = StraightGear.Create(ActiveIPart, gearDataL, gearDataR, toothProfileL, helicalAngle, screwAngleL, depth);
gearR = StraightGear.Create(ActiveIPart, gearDataR, gearDataL, toothProfileR, -helicalAngle, screwAngleR, depth);
}
Line zAxis = Line.Create(Point.Origin, Direction.DirZ);
gearL.Component.Transform(
Matrix.CreateMapping(frame) *
Matrix.CreateRotation(zAxis, Math.PI) *
gearL.TransformToTangent *
Matrix.CreateRotation(zAxis, gearDataL.PitchAngle * ((double)1 / 2 + (gearDataL.NumberOfTeeth % 2 == 0 && !isHypoid ? -1 : 0)))
);
gearR.Component.Transform(
Matrix.CreateMapping(frame) *
gearR.TransformToTangent *
Matrix.CreateRotation(zAxis, gearDataR.PitchAngle * ((double)1 / 2 + (gearDataR.NumberOfTeeth % 2 == 0 && !isHypoid ? -1 : 0)))
);
// if (gearDataR.NumberOfTeeth % 2 == 0)
// gearR.Component.Transform(Matrix.CreateRotation(Line.Create(Point.Origin, Direction.DirZ), gearDataR.PitchAngle));
//gearR.Component.Transform(gearR.TransformToTangent);
Part parent = ActiveIPart.Master;
IDesignFace pitchCircleL = gearL.Component.Content.Bodies.Where(b => b.Master == gearL.PitchCircleDesBody).First().Faces.First();
IDesignFace pitchCircleR = gearR.Component.Content.Bodies.Where(b => b.Master == gearR.PitchCircleDesBody).First().Faces.First();
Part gearMountPart = Part.Create(parent.Document, String.Format(Resources.GearMountPartName, gearDataL.NumberOfTeeth, gearDataR.NumberOfTeeth));
Component gearMountComponent = Component.Create(parent, gearMountPart);
DesignBody mountBodyL = DesignBody.Create(gearMountPart, string.Format(Resources.MountBodyName, gearDataL.NumberOfTeeth), pitchCircleL.Master.Shape.Body.CreateTransformedCopy(pitchCircleL.TransformToMaster.Inverse));
DesignBody mountBodyR = DesignBody.Create(gearMountPart, string.Format(Resources.MountBodyName, gearDataR.NumberOfTeeth), pitchCircleR.Master.Shape.Body.CreateTransformedCopy(pitchCircleR.TransformToMaster.Inverse));
IDesignFace mountCircleL = gearMountComponent.Content.Bodies.Where(b => b.Master == mountBodyL).First().Faces.First();
IDesignFace mountCircleR = gearMountComponent.Content.Bodies.Where(b => b.Master == mountBodyR).First().Faces.First();
Layer mountLayer = NoteHelper.CreateOrGetLayer(ActiveDocument, Resources.GearMountAlignmentCircleLayer, System.Drawing.Color.LightGray);
mountLayer.SetVisible(null, false);
mountBodyL.Layer = mountLayer;
mountBodyR.Layer = mountLayer;
MatingCondition matingCondition;
matingCondition = AnchorCondition.Create(parent, gearMountComponent);
matingCondition = AlignCondition.Create(parent, mountCircleL, pitchCircleL);
matingCondition = AlignCondition.Create(parent, mountCircleR, pitchCircleR);
// matingCondition = TangentCondition.Create(parent, pitchCircleL, pitchCircleR);
GearCondition gearCondition = GearCondition.Create(parent, pitchCircleL, pitchCircleR);
if (gearDataL.IsInternal ^ gearDataR.IsInternal)
{
gearCondition.IsBelt = true;
}
ActiveWindow.InteractionMode = InteractionMode.Solid;
Settings.Default.NumberOfTeethL = numberOfTeethL;
Settings.Default.NumberOfTeethR = numberOfTeethR;
Settings.Default.PressureAngleDegrees = pressureAngle * 180 / Math.PI;
Settings.Default.Module = module;
Settings.Default.Depth = depth;
Settings.Default.DedendumClearance = dedendumClearance;
Settings.Default.UseTrochoidalInterferenceRemoval = useTrochoidalInterferenceRemoval;
Settings.Default.AddDedendumClearace = addDedendumClearance;
Settings.Default.IsBevel = isBevel;
if (isBevel)
{
Settings.Default.BevelAngle = bevelAngle * 180 / Math.PI;
Settings.Default.BevelKneeRatio = bevelKneeRatio;
}
Settings.Default.IsHelical = isHelical;
Settings.Default.HelicalAngle = helicalAngle * 180 / Math.PI;
Settings.Default.IsScrew = isScrew;
Settings.Default.ScrewAngle = screwAngle * 180 / Math.PI;
Settings.Default.ScrewAngleOffset = screwAngleOffset * 180 / Math.PI;
Settings.Default.IsHypoid = isHypoid;
Settings.Default.HypoidAngle = hypoidAngle * 180 / Math.PI;
Settings.Default.HypoidOffset = hypoidOffset * lengthConversion;
Settings.Default.Save();
}
//Method returning the FitConfig instance (i.e., including the basic rules determining when a fit is valid) associated with the given input conditions
private FitConfig getAssociatedFitConfig(Accuracy expectedAccuracy)
{
FitConfig curFitConfig = new FitConfig();
if (expectedAccuracy == Accuracy.High)
{
curFitConfig.averLimit = 0.05;
curFitConfig.minPercBelowLimit = 0.85;
curFitConfig.globalAver = 0.10;
curFitConfig.minNoCases = 50;
}
else if (expectedAccuracy == Accuracy.Medium)
{
curFitConfig.averLimit = 0.15;
curFitConfig.minPercBelowLimit = 0.8;
curFitConfig.globalAver = 0.25;
curFitConfig.minNoCases = 35;
}
else if (expectedAccuracy == Accuracy.Low)
{
curFitConfig.averLimit = 0.3;
curFitConfig.minPercBelowLimit = 0.7;
curFitConfig.globalAver = 0.35;
curFitConfig.minNoCases = 20;
}
curFitConfig.expectedAccuracy = expectedAccuracy;
return curFitConfig;
}
//Method returning the color associated with the input accuracy (e.g., Green for High)
private Color getAccuracyColor(Accuracy curAccuracy)
{
Color curColor = Color.DarkGreen;
if (curAccuracy == Accuracy.Medium)
{
curColor = Color.DarkOrange;
}
else if (curAccuracy == Accuracy.Low)
{
curColor = Color.DarkRed;
}
return curColor;
}
private double GetPp(Beatmap beatmap, double acc, Mods mods = Mods.NoMod)
{
_accCalculator = new Accuracy(acc, beatmap.Objects.Count, 0);
_ppCalculator = new PPv2(new PPv2Parameters(beatmap, _accCalculator.Count100, _accCalculator.Count50, _accCalculator.CountMiss, -1, _accCalculator.Count300, mods));
return(Math.Round(_ppCalculator.Total, 2));
}
public ComputeJobOptimizationAttribute(Accuracy accuracy, Support support) : base(accuracy, support)
{
}
public BurstCompileAttribute(Accuracy accuracy, Support support)
{
Support = support;
Accuracy = accuracy;
}
public static void setAccuracy(this Criteria criteria, Accuracy value)
{
criteria.Accuracy = value;
}
/// <summary>
/// Parallelized OCR Orientation Confidence Detector, this method will run ocr on
/// an image and its corresponding reversed images and return the confidence and
/// both the ocrdata objects
/// </summary>
/// <param name="regs">Images with default regular orientation</param>
/// <param name="revs">Images with reversed orientation to default</param>
/// <param name="mode">OCR accuracy mode</param>
/// <param name="lang">OCR languages</param>
/// <param name="enableTimer">Enable timer for diagnostic purposes</param>
/// <returns>Tuple containing confidence, regular ocrdata and reversed ocrdata.
/// Positive confidence is for Regular where as negative
/// confidences is for Reversed</returns>
public static Tuple<long, OcrData, OcrData>[] ParallelDetectOrientation(
Bitmap[] regs,
Bitmap[] revs,
Accuracy mode = Accuracy.High,
string lang = "eng",
bool enableTimer = false)
{
if (regs.Length != revs.Length)
{
throw new ArgumentException("Input Arrays must be same length!");
}
// create new array and copy over image references
int pivot = regs.Length;
Bitmap[] images = new Bitmap[regs.Length + revs.Length];
Array.Copy(regs, images, pivot);
Array.Copy(revs, 0, images, pivot, pivot);
// Run Parallel Recognition on the arrays
OcrData[] datas = ParallelRecognize(images, pivot + pivot, mode, lang, enableTimer);
// Extract results and calculate confidence
Tuple<long, OcrData, OcrData>[] results = new Tuple<long, OcrData, OcrData>[pivot];
for (int ii = 0; ii < pivot; ii++)
{
OcrData reg = datas[ii];
OcrData rev = datas[ii + pivot];
// If postive we are confident about the current orientation
// if negative we are not confident about the current orientation
long confidence = rev.Cost - reg.Cost;
results[ii] = new Tuple<long, OcrData, OcrData>(confidence, reg, rev);
}
return results;
}
/// <summary>
/// Execute OCR on a given image, this static member will process the image,
/// Safely open, execute and dispose a Tesseract Object and store the result
/// in a new OcrData object.
/// </summary>
/// <param name="original"> Image to be OCR-ed </param>
/// <param name="mode"> Accuracy setting </param>
/// <param name="lang"> Language of text for OCR Language Model </param>
/// <param name="enableTimer"> Measure the Scantime for Diagnostic purposes </param>
/// <returns> </returns>
public static OcrData Recognize(Bitmap original,
Accuracy mode = Accuracy.High,
string lang = "eng",
bool enableTimer = false)
{
Image<Bgra, byte> img = new Image<Bgra, byte>(original);
Image<Gray, byte> processed;
Tesseract.Charactor[] chars;
String text;
long confidence;
long scantime = Int64.MinValue;
using (OCR ocr = new OCR(mode, lang, enableTimer))
{
processed = ocr.Preprocess(img);
ocr.Scan(processed);
confidence = ocr.OverallCost();
chars = ocr.Charactors();
text = ocr.Text();
if (enableTimer)
{
scantime = ocr.Elapsed();
ocr.Stop();
}
}
img.Dispose();
if (scantime == Int64.MinValue)
{
return new OcrData(processed, chars, text, confidence);
}
return new OcrData(processed, chars, text, confidence, scantime);
}
/// <summary>
/// Search by coordinates.
/// </summary>
/// <param name="coordinates">The coordinates.</param>
/// <param name="metric"> The metric.</param>
/// <param name="language"> The language.</param>
/// <param name="count"> The count.</param>
/// <param name="accuracy"> The accuracy.</param>
/// <returns>
/// Task {SearchResponse}.
/// </returns>
/// <seealso cref="M:OpenWeatherMap.ISearchClient.GetByCoordinates(Coordinates,MetricSystem,OpenWeatherMapLanguage,int?,Accuracy?)"/>
public Task<SearchResponse> GetByCoordinates(Coordinates coordinates, MetricSystem metric = MetricSystem.Internal, OpenWeatherMapLanguage language = OpenWeatherMapLanguage.EN, int? count = null, Accuracy? accuracy = null)
{
return this.GetByCoordinates<SearchResponse>(coordinates, metric, language, count, accuracy);
}
private static void Main()
{
const int imageSize = 28;
int[] layers = { 128, 64, 10 };
const int batchSize = 100;
const int maxEpoch = 10;
const float learningRate = 0.1f;
const float weightDecay = 1e-2f;
var trainIter = new MXDataIter("MNISTIter")
.SetParam("image", "./mnist_data/train-images-idx3-ubyte")
.SetParam("label", "./mnist_data/train-labels-idx1-ubyte")
.SetParam("batch_size", batchSize)
.SetParam("flat", 1)
.CreateDataIter();
var valIter = new MXDataIter("MNISTIter")
.SetParam("image", "./mnist_data/t10k-images-idx3-ubyte")
.SetParam("label", "./mnist_data/t10k-labels-idx1-ubyte")
.SetParam("batch_size", batchSize)
.SetParam("flat", 1)
.CreateDataIter();
var net = Mlp(layers);
Context ctx = Context.Gpu(); // Use GPU for training
var args = new SortedDictionary <string, NDArray>();
args["X"] = new NDArray(new Shape(batchSize, imageSize * imageSize), ctx);
args["label"] = new NDArray(new Shape(batchSize), ctx);
// Let MXNet infer shapes of other parameters such as weights
net.InferArgsMap(ctx, args, args);
// Initialize all parameters with uniform distribution U(-0.01, 0.01)
var initializer = new Uniform(0.01f);
foreach (var arg in args)
{
// arg.first is parameter name, and arg.second is the value
initializer.Operator(arg.Key, arg.Value);
}
// Create sgd optimizer
var opt = OptimizerRegistry.Find("sgd");
opt.SetParam("rescale_grad", 1.0 / batchSize)
.SetParam("lr", learningRate)
.SetParam("wd", weightDecay);
var lrSch = new UniquePtr <LRScheduler>(new FactorScheduler(5000, 0.1f));
opt.SetLearningRateScheduler(lrSch);
// Create executor by binding parameters to the model
using (var exec = net.SimpleBind(ctx, args))
{
var argNames = net.ListArguments();
// Create metrics
Accuracy trainAcc = new Accuracy();
Accuracy valAcc = new Accuracy();
// Start training
var sw = new Stopwatch();
for (var iter = 0; iter < maxEpoch; ++iter)
{
var samples = 0;
trainIter.Reset();
trainAcc.Reset();
sw.Restart();
while (trainIter.Next())
{
samples += batchSize;
var dataBatch = trainIter.GetDataBatch();
// Data provided by DataIter are stored in memory, should be copied to GPU first.
dataBatch.Data.CopyTo(args["X"]);
dataBatch.Label.CopyTo(args["label"]);
// CopyTo is imperative, need to wait for it to complete.
NDArray.WaitAll();
// Compute gradients
exec.Forward(true);
exec.Backward();
// Update parameters
for (var i = 0; i < argNames.Count; ++i)
{
if (argNames[i] == "X" || argNames[i] == "label")
{
continue;
}
opt.Update(i, exec.ArgmentArrays[i], exec.GradientArrays[i]);
}
// Update metric
trainAcc.Update(dataBatch.Label, exec.Outputs[0]);
}
// one epoch of training is finished
sw.Stop();
var duration = sw.ElapsedMilliseconds / 1000.0;
Logging.LG($"Epoch[{iter}] {samples / duration} samples/sec Train-Accuracy={trainAcc.Get()}");
valIter.Reset();
valAcc.Reset();
while (valIter.Next())
{
var dataBatch = valIter.GetDataBatch();
dataBatch.Data.CopyTo(args["X"]);
dataBatch.Label.CopyTo(args["label"]);
NDArray.WaitAll();
// Only forward pass is enough as no gradient is needed when evaluating
exec.Forward(false);
valAcc.Update(dataBatch.Label, exec.Outputs[0]);
}
Logging.LG($"Epoch[{iter}] Val-Accuracy={valAcc.Get()}");
}
}
MXNet.MXNotifyShutdown();
}
/// <summary>
/// Search by city name.
/// </summary>
/// <param name="cityName">Name of the city.</param>
/// <param name="metric"> The metric.</param>
/// <param name="language">The language.</param>
/// <param name="count"> The count.</param>
/// <param name="accuracy">The accuracy.</param>
/// <returns>
/// Task {SearchResponse}.
/// </returns>
/// <seealso cref="M:OpenWeatherMap.ISearchClient.GetByName(string,MetricSystem,OpenWeatherMapLanguage,int?,Accuracy?)"/>
public Task<SearchResponse> GetByName(string cityName, MetricSystem metric = MetricSystem.Internal, OpenWeatherMapLanguage language = OpenWeatherMapLanguage.EN, int? count = null, Accuracy? accuracy = null)
{
return this.GetByName<SearchResponse>(cityName, metric, language, count, accuracy);
}
/// <summary>
/// Returns a detailed <see cref="System.String"/> that represents this confusion matrix.
/// </summary>
/// <returns>A <see cref="System.String"/> that represents this confusion matrix.</returns>
/// <remarks></remarks>
public override string ToString()
{
// Write the summary values
string summary = "";
summary += "Correct: " + Correct;
summary += " Incorrect: " + Incorrect;
summary += " Total: " + Observations;
summary += " Accuracy: " + Accuracy.ToString("F4");
summary += " Error: " + Error.ToString("F4");
summary += " Confidence: +/- " + ConfidenceInterval.ToString("F4");
summary += " Variance: " + Variance.ToString("F4");
summary += "\n\n\n";
// Calculate padding values
int[] padding = new int[values.Count + 1];
int i;
int sp = 2;
foreach (KeyValuePair <string, SortedDictionary <string, int> > pair in values)
{
if (pair.Key.Length > padding[0])
{
padding[0] = pair.Key.Length;
}
i = 1;
foreach (KeyValuePair <string, int> pair2 in pair.Value)
{
if (pair2.Value.ToString().Length > padding[i])
{
padding[i] = pair2.Value.ToString().Length;
}
i += 1;
}
}
// Write the header
string output = "";
output += "".PadRight(padding[0] + 3);
i = 1;
foreach (KeyValuePair <string, SortedDictionary <string, int> > pair in values)
{
output += pair.Key.PadRight(padding[i] + sp);
i += 1;
}
output += "\n ".PadRight(output.Length, '-') + "\n";
// Write each horizontal line
foreach (KeyValuePair <string, SortedDictionary <string, int> > pair in values)
{
output += pair.Key.PadRight(padding[0]) + " | ";
i = 1;
foreach (KeyValuePair <string, int> pair2 in pair.Value)
{
output += pair2.Value.ToString().PadRight(padding[i] + sp);
i += 1;
}
output += "\n";
}
output += "\n\nConfusions:\n\n" + Confusions(-1);
return(summary + output + "\n");
}
public override Effect GetEffect()
{
PassiveEffect = new Accuracy(Level);
return(PassiveEffect);
}
/// <summary>
/// Saves the data into a <see cref="XmlDocument"/> and returns it. It's up to caller to actually save the XML into a file. Optionally a closure can be assigned that will be called with the main project node - in case additional data needs to be saved.
/// </summary>
public XmlDocument Save(Action <XmlNode> projectNodeHandler = null)
{
var document = new XmlDocument();
// Root node
var rootNode = document.CreateElement("", "XML", "");
document.AppendChild(rootNode);
// Project root node
var projectNode = rootNode.AddNode("Project");
// Project name node
var nameNode = projectNode.AddNode("Name");
nameNode.AddAttribute("Projectname", Name);
// Filenames
foreach (var image in Images)
{
var fileNode = projectNode.AddNode("File");
fileNode.AddAttribute("Path", image.Filename);
}
// Settings
var settingsNode = projectNode.AddNode("Settings");
switch (OutputType)
{
case OutputType.Sprites: settingsNode.AddAttribute("sprites", "true"); break;
case OutputType.Tiles: settingsNode.AddAttribute("blocks", "true"); break;
}
settingsNode.AddAttribute("comments", (int)CommentType);
settingsNode.AddAttribute("center", CenterPosition);
settingsNode.AddAttribute("xSize", GridWidth);
settingsNode.AddAttribute("ySize", GridHeight);
settingsNode.AddAttribute("fourBit", FourBit);
settingsNode.AddAttribute("binary", BinaryOutput);
settingsNode.AddAttribute("binaryBlocks", BinaryBlocksOutput);
settingsNode.AddAttribute("Repeats", IgnoreCopies);
settingsNode.AddAttribute("MirrorX", IgnoreMirroredX);
settingsNode.AddAttribute("MirrorY", IgnoreMirroredY);
settingsNode.AddAttribute("Rotations", IgnoreRotated);
settingsNode.AddAttribute("Transparent", IgnoreTransparentPixels);
settingsNode.AddAttribute("Sort", TransparentFirst);
settingsNode.AddAttribute("blocksImage", BlocksAsImage);
settingsNode.AddAttribute("tilesImage", TilesAsImage);
settingsNode.AddAttribute("transBlock", TransparentBlocks);
settingsNode.AddAttribute("transTile", TransparentTiles);
settingsNode.AddAttribute("across", BlocsAcross.ToString());
settingsNode.AddAttribute("accurate", Accuracy.ToString());
settingsNode.AddAttribute("format", (int)ImageFormat);
settingsNode.AddAttribute("textFlips", TextFlips);
settingsNode.AddAttribute("reduce", Reduced);
// Palette
var paletteNode = projectNode.AddNode("Palette");
paletteNode.AddAttribute("Mapping", Enum.GetName(typeof(PaletteType), Palette.Type));
paletteNode.AddAttribute("Transparent", Palette.TransparentIndex.ToString());
paletteNode.AddAttribute("Used", Palette.UsedCount.ToString());
for (int i = 0; i < Palette.Colours.Count; i++)
{
var colourNode = paletteNode.AddNode($"Colour{i}");
var colour = Palette.Colours[i];
colourNode.AddAttribute("Red", colour.Red.ToString());
colourNode.AddAttribute("Green", colour.Green.ToString());
colourNode.AddAttribute("Blue", colour.Blue.ToString());
}
// Dialogs
var dialogsNode = projectNode.AddNode("Dialogs");
dialogsNode.AddAttribute("OutputIndex", OutputFilesFilterIndex.ToString());
dialogsNode.AddAttribute("ImageIndex", AddImagesFilterIndex.ToString());
// After all data is saved, pass project node to closure so additional data can be appended.
if (projectNodeHandler != null)
{
projectNodeHandler(projectNode);
}
return(document);
}
public SilencedPistol()
{
AccuracyChart = Accuracy.GetAccuracyChart(this);
}
public GenTimeAccuracy(Accuracy accuracy)
{
this.accuracy = accuracy;
}
public Rifle()
{
AccuracyChart = Accuracy.GetAccuracyChart(this);
}
//------------------------------------------------------------------------------
public TimeStampToken Generate(
TimeStampRequest request,
BigInteger serialNumber,
DateTime genTime)
{
DerObjectIdentifier digestAlgOID = new DerObjectIdentifier(request.MessageImprintAlgOid);
AlgorithmIdentifier algID = new AlgorithmIdentifier(digestAlgOID, DerNull.Instance);
MessageImprint messageImprint = new MessageImprint(algID, request.GetMessageImprintDigest());
Accuracy accuracy = null;
if (accuracySeconds > 0 || accuracyMillis > 0 || accuracyMicros > 0)
{
DerInteger seconds = null;
if (accuracySeconds > 0)
{
seconds = new DerInteger(accuracySeconds);
}
DerInteger millis = null;
if (accuracyMillis > 0)
{
millis = new DerInteger(accuracyMillis);
}
DerInteger micros = null;
if (accuracyMicros > 0)
{
micros = new DerInteger(accuracyMicros);
}
accuracy = new Accuracy(seconds, millis, micros);
}
DerBoolean derOrdering = null;
if (ordering)
{
derOrdering = DerBoolean.GetInstance(ordering);
}
DerInteger nonce = null;
if (request.Nonce != null)
{
nonce = new DerInteger(request.Nonce);
}
DerObjectIdentifier tsaPolicy = new DerObjectIdentifier(tsaPolicyOID);
if (request.ReqPolicy != null)
{
tsaPolicy = new DerObjectIdentifier(request.ReqPolicy);
}
TstInfo tstInfo = new TstInfo(tsaPolicy, messageImprint,
new DerInteger(serialNumber), new DerGeneralizedTime(genTime), accuracy,
derOrdering, nonce, tsa, request.Extensions);
try
{
CmsSignedDataGenerator signedDataGenerator = new CmsSignedDataGenerator();
byte[] derEncodedTstInfo = tstInfo.GetDerEncoded();
if (request.CertReq)
{
signedDataGenerator.AddCertificates(x509Certs);
}
signedDataGenerator.AddCrls(x509Crls);
signedDataGenerator.AddSigner(key, cert, digestOID, signedAttr, unsignedAttr);
CmsSignedData signedData = signedDataGenerator.Generate(
PkcsObjectIdentifiers.IdCTTstInfo.Id,
new CmsProcessableByteArray(derEncodedTstInfo),
true);
return(new TimeStampToken(signedData));
}
catch (CmsException cmsEx)
{
throw new TspException("Error generating time-stamp token", cmsEx);
}
catch (IOException e)
{
throw new TspException("Exception encoding info", e);
}
catch (X509StoreException e)
{
throw new TspException("Exception handling CertStore", e);
}
// catch (InvalidAlgorithmParameterException e)
// {
// throw new TspException("Exception handling CertStore CRLs", e);
// }
}
public Pistol()
{
AccuracyChart = Accuracy.GetAccuracyChart(this);
}
public override int GetHashCode()
{
int hash = 1;
if (MoveId != 0)
{
hash ^= MoveId.GetHashCode();
}
if (Category != global::ReMastersLib.Category.NoCategory)
{
hash ^= Category.GetHashCode();
}
if (U3 != 0)
{
hash ^= U3.GetHashCode();
}
if (User != global::ReMastersLib.User.Pokemon)
{
hash ^= User.GetHashCode();
}
if (Group != global::ReMastersLib.Group.None)
{
hash ^= Group.GetHashCode();
}
if (Type != 0)
{
hash ^= Type.GetHashCode();
}
if (Target != global::ReMastersLib.Target.AllySingle)
{
hash ^= Target.GetHashCode();
}
if (U8 != 0)
{
hash ^= U8.GetHashCode();
}
if (GaugeDrain != 0)
{
hash ^= GaugeDrain.GetHashCode();
}
if (Power != 0)
{
hash ^= Power.GetHashCode();
}
if (Accuracy != 0)
{
hash ^= Accuracy.GetHashCode();
}
if (Uses != 0)
{
hash ^= Uses.GetHashCode();
}
if (Tags != global::ReMastersLib.Tag.None)
{
hash ^= Tags.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public static Body CreatePolygon(IList <Point> inputPoints, Plane plane, double thickness)
{
List <ITrimmedCurve> profile = new List <ITrimmedCurve>();
if (plane == null)
{
if (!AddInHelper.TryCreatePlaneFromPoints(inputPoints, out plane))
{
return(null);
}
}
Point newPoint;
Point lastPoint = inputPoints[inputPoints.Count - 1].ProjectToPlane(plane);
List <Point> points = new List <Point>();
foreach (Point point in inputPoints)
{
newPoint = point.ProjectToPlane(plane);
if (!Accuracy.Equals(newPoint, lastPoint))
{
points.Add(newPoint);
lastPoint = newPoint;
}
}
for (int i = 0; i < points.Count; i++)
{
if (i < points.Count - 1)
{
profile.Add(CurveSegment.Create(points[i], points[i + 1]));
}
else
{
profile.Add(CurveSegment.Create(points[i], points[0]));
}
}
Body body = null;
try {
if (thickness == 0)
{
body = Body.CreatePlanarBody(plane, profile);
}
else
{
body = Body.ExtrudeProfile(plane, profile, thickness);
}
}
catch {
string error = "Exception thrown creating planar body:\n";
foreach (Point point in inputPoints)
{
error += string.Format("{0}, {1}, {2}\n", point.X, point.Y, point.Z);
}
Debug.Assert(false, error);
}
if (body == null)
{
Debug.Fail("Profile was not connected, not closed, or not in order.");
return(null);
}
return(body);
}
public void Save(int moveNum)
{
if (!Directory.Exists(Paths.DataPath + "Move"))
{
Directory.CreateDirectory(Paths.DataPath + "Move");
}
using (XmlWriter writer = XmlWriter.Create(Paths.DataPath + "Move\\" + moveNum + ".xml", Logger.XmlWriterSettings)) {
writer.WriteStartDocument();
writer.WriteStartElement("MoveEntry");
#region Basic data
writer.WriteStartElement("General");
writer.WriteElementString("Name", Name);
writer.WriteElementString("Description", Desc);
writer.WriteElementString("PP", PP.ToString());
writer.WriteElementString("Type", Type.ToString());
writer.WriteElementString("Category", Category.ToString());
writer.WriteElementString("Contact", Contact.ToString());
writer.WriteElementString("SoundBased", SoundBased.ToString());
writer.WriteElementString("FistBased", FistBased.ToString());
writer.WriteElementString("PulseBased", PulseBased.ToString());
writer.WriteElementString("BulletBased", BulletBased.ToString());
writer.WriteElementString("JawBased", BulletBased.ToString());
writer.WriteElementString("Power", Power.ToString());
writer.WriteElementString("Accuracy", Accuracy.ToString());
writer.WriteElementString("Effect", Effect.ToString());
writer.WriteElementString("Effect1", Effect1.ToString());
writer.WriteElementString("Effect2", Effect2.ToString());
writer.WriteElementString("Effect3", Effect3.ToString());
writer.WriteElementString("HitsSelf", Range.HitsSelf.ToString());
writer.WriteElementString("HitsFriend", Range.HitsFriend.ToString());
writer.WriteElementString("HitsFoe", Range.HitsFoe.ToString());
writer.WriteElementString("Range", Range.RangeType.ToString());
writer.WriteElementString("Mobility", Range.Mobility.ToString());
writer.WriteElementString("CutsCorners", Range.CutsCorners.ToString());
writer.WriteElementString("Distance", Range.Distance.ToString());
writer.WriteStartElement("StartAnim");
StartAnim.Save(writer);
writer.WriteEndElement();
writer.WriteStartElement("StartUserAnim");
StartUserAnim.Save(writer);
writer.WriteEndElement();
writer.WriteElementString("StartSound", StartSound.ToString());
writer.WriteStartElement("MidAnim");
MidAnim.Save(writer);
writer.WriteEndElement();
writer.WriteStartElement("MidUserAnim");
MidUserAnim.Save(writer);
writer.WriteEndElement();
writer.WriteStartElement("MidTargetAnim");
MidTargetAnim.Save(writer);
writer.WriteEndElement();
writer.WriteElementString("MidSound", MidSound.ToString());
writer.WriteStartElement("EndAnim");
EndAnim.Save(writer);
writer.WriteEndElement();
writer.WriteStartElement("EndUserAnim");
EndUserAnim.Save(writer);
writer.WriteEndElement();
writer.WriteStartElement("EndTargetAnim");
EndTargetAnim.Save(writer);
writer.WriteEndElement();
writer.WriteElementString("EndSound", EndSound.ToString());
writer.WriteEndElement();
#endregion
writer.WriteEndElement();
writer.WriteEndDocument();
}
}
public LocationMonitorImpl(Accuracy accuracy)
{
DesiredAccuracy = accuracy;
}
/// <summary>
/// Parallelized Recognize Function takes in a list or array of images,
/// A specified length and for each image returns an OCRData object
/// </summary>
/// <param name="images"> Array or List of Bitmaps </param>
/// <param name="length"> Number of items to be Recognized from the array </param>
/// <param name="mode"> Accuracy Mode </param>
/// <param name="lang"> Desired OCR Language </param>
/// <param name="enableTimer"> Enables OCR Scan Timer if true </param>
/// <returns> </returns>
public static OcrData[] ParallelRecognize(IEnumerable<Bitmap> images,
int length,
Accuracy mode = Accuracy.High,
string lang = "eng",
bool enableTimer = false)
{
Tuple<int, Bitmap>[] indexedImages = new Tuple<int, Bitmap>[length];
int index = 0;
foreach (Bitmap image in images)
{
if (index >= length)
{
break;
}
indexedImages[index] = new Tuple<int, Bitmap>(index, image);
index += 1;
}
ConcurrentDictionary<int, OcrData> safeMap = new ConcurrentDictionary<int, OcrData>();
Parallel.ForEach(indexedImages, pair =>
{
int position = pair.Item1;
Bitmap image = pair.Item2;
safeMap[position] = Recognize(image, mode, lang, enableTimer);
});
OcrData[] data = new OcrData[length];
foreach (KeyValuePair<int, OcrData> kvpair in safeMap)
{
data[kvpair.Key] = kvpair.Value;
}
return data;
}
public void TestData()
{
var trainingData = ReadTestData("../../../../Data/train_sensor.txt", "../../../../Data/train_category.txt");
var columnCount = 300;
var cellsPerColumn = 1;
var floatPrecision = 50;
var node = new Node(
inputCount: 32 * floatPrecision,
columnCount: columnCount,
cellsPerColumn: cellsPerColumn,
desiredLocalActivity: 10,
minOverlap: 2,
maxSynapsesPerColumn: 20,
newSynapseCount: 2
);
var cl = new AlsingClassifier();
foreach (var frame in trainingData)
node.Feed(BitMapper.Map(frame.Columns, -0.6f, 2.21f, floatPrecision));
using (var log = new StreamWriter("../../../../Data/train_result.txt", false, Encoding.ASCII))
foreach (var frame in trainingData)
{
node.Feed(BitMapper.Map(frame.Columns, -0.6f, 2.21f, floatPrecision));
cl.Train(frame.Category.ToString(), node.ToArray());
log.WriteLine(node.Select(v => v ? '1' : '0').ToArray());
}
node.Learning = false;
var testData = ReadTestData("../../../../Data/test_sensor.txt", "../../../../Data/test_category.txt");
var acurate = 0;
var total = 0;
var accuracy = new Dictionary<string, Accuracy>();
using (var log = new StreamWriter("../../../../Data/test_result.txt", false, Encoding.ASCII))
foreach (var frame in testData)
{
var activeCount = 0;
Func<int, bool> input = BitMapper.Map(frame.Columns, -0.6f, 2.21f, floatPrecision);
node.Feed(input);
foreach (var b in node)
if (b)
activeCount++;
var matches = cl.FindMatches(node.ToArray())
.OrderByDescending(c => c.Strength)
.Take(2)
.ToArray();
log.WriteLine(node.Select(d => d ? '1' : '0').ToArray());
/*for (var i = 0; i < 32 * 50; i++)
Console.Write(input(i) ? "1" : "0");
Console.WriteLine();
Console.WriteLine(String.Join("", outputData.Select(v => v ? "1" : "0")));*/
var cat = frame.Category.ToString();
if (matches[0].Identifier == cat) acurate++;
total++;
Accuracy v;
if (!accuracy.TryGetValue(cat, out v))
accuracy.Add(cat, v = new Accuracy());
if (matches[0].Identifier == frame.Category.ToString()) v.acurate++;
v.total++;
Console.WriteLine("Expected: {0} Matched: {1} ({3:p}) Runner Up: {2} ({4:p}) Activity Count: {5}", frame.Category, matches[0].Identifier, matches[1].Identifier, matches[0].Strength, matches[1].Strength, activeCount);
}
Console.WriteLine("Accuracy: {0:p}", ((float)acurate) / ((float)total));
foreach (var pair in accuracy)
Console.WriteLine("Accuracy {1}: {0:p}", ((float)pair.Value.acurate) / ((float)pair.Value.total), pair.Key);
}
private static extern short NOVAS_SiderealTime(double jdHigh, double jdLow, double detlaT, GstType gstType, Method method, Accuracy accuracy, ref double gst);
public static void RunConv()
{
var mnist = TestUtils.GetMNIST();
var batch_size = 128;
var train_data = new NDArrayIter(mnist["train_data"], mnist["train_label"], batch_size, true);
var val_data = new NDArrayIter(mnist["test_data"], mnist["test_label"], batch_size);
var net = new Sequential();
net.Add(new Conv2D(20, kernel_size: (5, 5), activation: ActivationType.Tanh));
net.Add(new MaxPool2D(pool_size: (2, 2), strides: (2, 2)));
net.Add(new Conv2D(50, kernel_size: (5, 5), activation: ActivationType.Tanh));
net.Add(new MaxPool2D(pool_size: (2, 2), strides: (2, 2)));
net.Add(new Flatten());
net.Add(new Dense(500, ActivationType.Tanh));
net.Add(new Dense(10));
var gpus = TestUtils.ListGpus();
var ctx = gpus.Count > 0 ? gpus.Select(x => Context.Gpu(x)).ToArray() : new[] { Context.Cpu(0) };
net.Initialize(new Xavier(magnitude: 2.24f), ctx);
var trainer = new Trainer(net.CollectParams(), new SGD(learning_rate: 0.02f));
var epoch = 10;
var metric = new Accuracy();
var softmax_cross_entropy_loss = new SoftmaxCELoss();
float lossVal = 0;
for (var iter = 0; iter < epoch; iter++)
{
var tic = DateTime.Now;
train_data.Reset();
lossVal = 0;
while (!train_data.End())
{
var batch = train_data.Next();
var data = Utils.SplitAndLoad(batch.Data[0], ctx, batch_axis: 0);
var label = Utils.SplitAndLoad(batch.Label[0], ctx, batch_axis: 0);
var outputs = new NDArrayList();
using (var ag = Autograd.Record())
{
for (var i = 0; i < data.Length; i++)
{
var x = data[i];
var y = label[i];
var z = net.Call(x);
NDArray loss = softmax_cross_entropy_loss.Call(z, y);
loss.Backward();
lossVal += loss.Mean();
outputs.Add(z);
}
//outputs = Enumerable.Zip(data, label, (x, y) =>
//{
// var z = net.Call(x);
// NDArray loss = softmax_cross_entropy_loss.Call(z, y);
// loss.Backward();
// lossVal += loss.Mean();
// return z;
//}).ToList();
}
metric.Update(label, outputs.ToArray());
trainer.Step(batch.Data[0].Shape[0]);
}
var toc = DateTime.Now;
var(name, acc) = metric.Get();
metric.Reset();
Console.Write($"Loss: {lossVal} ");
Console.WriteLine($"Training acc at epoch {iter}: {name}={(acc * 100).ToString("0.##")}%, Duration: {(toc - tic).TotalSeconds.ToString("0.#")}s");
}
}
static void TestData(dynamic node, IEnumerable<TestFrame> trainingData, IEnumerable<TestFrame> testData, int warmUps, string trainingLog, string testLog, Func<float[], Func<int, bool>> floatMapper)
{
var enode = node as IEnumerable<bool>;
var cl = new AlsingClassifier();
var warmupStart = DateTime.Now;
for (var w = 0; w < warmUps; w++)
foreach (var frame in trainingData)
node.Feed(floatMapper(frame.Columns));
var warmupEnd = DateTime.Now;
var trainingStart = DateTime.Now;
using (var log = trainingLog == null ? null : new StreamWriter(trainingLog, false, Encoding.ASCII))
foreach (var frame in trainingData)
{
node.Feed(floatMapper(frame.Columns));
cl.Train(frame.Category.ToString(), enode.ToArray());
if (log != null) log.WriteLine(String.Join(" ", enode.Select(d => d ? '1' : '0')));
}
var trainingEnd = DateTime.Now;
node.Learning = false;
var acurate = 0;
var total = 0;
var accuracy = new Dictionary<string, Accuracy>();
var testStart = DateTime.Now;
using (var log = testLog == null ? null : new StreamWriter(testLog, false, Encoding.ASCII))
foreach (var frame in testData)
{
var activeCount = 0;
Func<int, bool> input = floatMapper(frame.Columns);
node.Feed(input);
foreach (var b in enode)
if (b)
activeCount++;
var matches = cl.FindMatches(enode.ToArray())
.OrderByDescending(c => c.Strength)
.Take(2)
.ToArray();
if (log != null) log.WriteLine(String.Join(" ", enode.Select(d => d ? '1' : '0')));
var cat = frame.Category.ToString();
if (matches[0].Identifier == cat) acurate++;
total++;
Accuracy v;
if (!accuracy.TryGetValue(cat, out v))
accuracy.Add(cat, v = new Accuracy());
if (matches[0].Identifier == frame.Category.ToString()) v.acurate++;
v.total++;
Console.WriteLine("Expected: {0} Matched: {1} ({3:p}) Runner Up: {2} ({4:p}) Activity Count: {5}", frame.Category, matches[0].Identifier, matches[1].Identifier, matches[0].Strength, matches[1].Strength, activeCount);
}
var testEnd = DateTime.Now;
Console.WriteLine("Accuracy: {0:p}", ((float)acurate) / ((float)total));
foreach (var pair in accuracy)
Console.WriteLine("Accuracy {1}: {0:p}", ((float)pair.Value.acurate) / ((float)pair.Value.total), pair.Key);
Console.WriteLine();
Console.WriteLine("Warm up:\t{0:g}", warmupEnd - warmupStart);
Console.WriteLine("Training:\t{0:g}", trainingEnd - trainingStart);
Console.WriteLine("Test:\t{0:g}", testEnd - testStart);
}
public static short SiderealTime(double jdHigh, double jdLow, double deltaT, GstType gstType, Method method, Accuracy accuracy, ref double gst)
{
return(NOVAS_SiderealTime(jdHigh, jdLow, deltaT, gstType, method, accuracy, ref gst));
}
/// <summary>
/// This function computes the apparent direction of a star or solar
/// system body at a specified time and in a specified coordinate system
/// </summary>
/// <param name="jdTt"></param>
/// <param name="celestialObject"></param>
/// <param name="observer"></param>
/// <param name="deltaT"></param>
/// <param name="coordinateSystem"></param>
/// <param name="accuracy"></param>
/// <param name="position"></param>
/// <returns></returns>
public static short Place(double jdTt, CelestialObject celestialObject, Observer observer, double deltaT, CoordinateSystem coordinateSystem, Accuracy accuracy, ref SkyPosition position)
{
lock (lockObj) {
var err = NOVAS_Place(jdTt, ref celestialObject, ref observer, deltaT, (short)coordinateSystem, (short)accuracy, ref position);
return(err);
}
}
private void UpdateAccuracy(double accuracy)
{
Accuracy.Text += Environment.NewLine + accuracy;
Accuracy.Refresh();
}
