public ActionResult Create(Guider guider)
{
if (ModelState.IsValid)
{
if (!(guider.File.ContentType == "image/jpeg" || guider.File.ContentType == "image/gif" || guider.File.ContentType == "image/png"))
{
ModelState.AddModelError("CustomError", "File type allowed : jpeg and gif");
RedirectToAction("Index");
}
else
{
string subPath = "~/UserImages";
bool exists = Directory.Exists(Server.MapPath(subPath));
if (!exists)
Directory.CreateDirectory(Server.MapPath(subPath));
var fileName = Path.GetFileName(guider.File.FileName);
var path = Path.Combine(Server.MapPath(subPath), fileName);
guider.File.SaveAs(path);
var pathName = subPath + "/" + Path.GetFileName(guider.File.FileName);
guider.img = pathName;
db.Guides.Add(guider);
db.SaveChanges();
}
return RedirectToAction("Index");
}
return View(guider);
}
public override string Replace(string input, Guider guider, IGuidFormatter formatter=null, bool upcase = false, Action<Replacement> onReplacement = null, int lineNumber = -1)
{
string output = (input != null)?input:"";
return s_B64.Replace(input, (m)=> {
string s = s_SpaceStripper.Replace(m.Value, "");
StringBuilder replacementText = new StringBuilder();
List<Guid> guids = new List<Guid>();
foreach(Guid g in ToGuid(s))
{
if (guider.MoveNext(g))
{
Guid replacementGuid = guider.Current;
guids.Add(replacementGuid);
string currentText = (formatter != null)?formatter.ToString(replacementGuid, upcase, false):replacementGuid.ToString("D");
if (formatter != null)
{
if (replacementText.Length > 0) replacementText.Append("\r\n");
replacementText.Append(currentText);
}
if (onReplacement != null) onReplacement(new Replacement() { Line=lineNumber, Column = m.Index, FoundText=g.ToString("D"), FoundGuid=g, ReplacedByText=currentText, ReplacedByGuid=replacementGuid });
}
}
if (guids.Count > 0 && replacementText.Length == 0) replacementText.Append(ToString(guids, upcase, false));
else if (guids.Count == 0) return m.Value;
return replacementText.ToString();
});
}
public ActionResult DeleteConfirmed(int id)
{
Guider guider = db.Guides.Find(id);
db.Guides.Remove(guider);
db.SaveChanges();
return RedirectToAction("Index");
}
public async Task <IActionResult> PutGuider(int id, [FromForm] Guider guider)
{
if (id != guider.GuiderId)
{
return(BadRequest());
}
if (guider.ImageFile != null)
{
DeleteImage(guider.ImageName);
guider.ImageName = await SaveImage(guider.ImageFile);
}
_context.Entry(guider).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GuiderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <bool> Dither(CancellationToken token)
{
if (Guider?.Connected == true)
{
try {
Guider.GuideEvent -= Guider_GuideEvent;
applicationStatusMediator.StatusUpdate(new Model.ApplicationStatus()
{
Status = Locale.Loc.Instance["LblDither"], Source = Title
});
GuideStepsHistory.AddDitherIndicator();
await Guider.Dither(token);
} finally {
Guider.GuideEvent += Guider_GuideEvent;
applicationStatusMediator.StatusUpdate(new Model.ApplicationStatus()
{
Status = string.Empty, Source = Title
});
}
return(true);
}
else
{
await Disconnect();
return(false);
}
}
public Guider GetGuider(string guiderId)
{
Guider selectedGuider = new Guider();
selectedGuider = db.Guiders.Find(guiderId);
return(selectedGuider);
}
public ActionResult Edit([Bind(Include = "ID,firstName,lastName,workedYear,img")] Guider guider)
{
if (ModelState.IsValid)
{
db.Entry(guider).State = EntityState.Modified;
db.SaveChanges();
return RedirectToAction("Index");
}
return View(guider);
}
public async Task <ActionResult <Guider> > PostGuider([FromForm] Guider guider)
{
guider.ImageName = await SaveImage(guider.ImageFile);
_context.Guiders.Add(guider);
await _context.SaveChangesAsync();
return(StatusCode(201));
}
public ActionResult Edit([Bind(Include = "id,Number,Password,Name,Phone")] Guider guider)
{
if (ModelState.IsValid)
{
db.Entry(guider).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(guider));
}
public ActionResult Create([Bind(Include = "id,Number,Password,Name,Phone")] Guider guider)
{
if (ModelState.IsValid)
{
db.Guider.Add(guider);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(guider));
}
public async Task <bool> StopGuiding(CancellationToken token)
{
if (Guider?.Connected == true)
{
return(await Guider.StopGuiding(token));
}
else
{
return(false);
}
}
public Task Disconnect()
{
if (Guider != null)
{
Guider.PropertyChanged -= Guider_PropertyChanged;
Guider.GuideEvent -= Guider_GuideEvent;
}
Guider?.Disconnect();
GuiderInfo = DeviceInfo.CreateDefaultInstance <GuiderInfo>();
BroadcastGuiderInfo();
return(Task.CompletedTask);
}
// GET: Guiders/Details/5
public ActionResult Details(int? id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Guider guider = db.Guides.Find(id);
if (guider == null)
{
return HttpNotFound();
}
return View(guider);
}
// GET: Guider/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Guider guider = db.Guider.Find(id);
if (guider == null)
{
return(HttpNotFound());
}
return(View(guider));
}
public async Task <bool> AutoSelectGuideStar(CancellationToken token)
{
if (Guider?.Connected == true)
{
var result = await Guider?.AutoSelectGuideStar();
await Task.Delay(TimeSpan.FromSeconds(5), token);
return(result);
}
else
{
return(false);
}
}
static void Main(string[] args)
{
string host = "localhost";
if (args.Length > 0)
{
host = args[0];
}
try
{
using (Guider guider = Guider.Factory(host))
{
guider.Connect();
var s = guider.GetStats();
double settlePixels = 2.0;
double settleTime = 20.0;
double settleTimeout = 60.0;
for (;;)
{
string state;
double avgDist;
guider.GetStatus(out state, out avgDist);
Console.WriteLine("{0} dist={1:F1}",
state, avgDist);
Thread.Sleep(2000);
if (state == "LostLock" || state == "Looping")
{
guider.StopCapture();
Thread.Sleep(5000);
guider.Guide(settlePixels, settleTime, settleTimeout);
WaitForSettleDone(guider);
Thread.Sleep(5000);
}
}
}
}
catch (Exception err)
{
Console.WriteLine("Error: {0}", err.Message);
}
Console.ReadLine();
}
static void WaitForSettleDone(Guider guider)
{
while (true)
{
SettleProgress s = guider.CheckSettling();
if (s.Done)
{
Console.WriteLine("settling is done");
break;
}
Console.WriteLine("settling dist {0:F1}/{1:F1} time {2:F1}/{3:F1}",
s.Distance, s.SettlePx, s.Time, s.SettleTime);
Thread.Sleep(1000);
}
}
public virtual string Replace(string input, Guider guider, IGuidFormatter formatter=null, bool upcase = false, Action<Replacement> onReplacement = null, int lineNumber = -1)
{
if (!string.IsNullOrEmpty(input))
{
return Matcher.Replace(input, (m) => {
Guid foundGuid = MatchToGuid(m);
if (guider.MoveNext(foundGuid))
{
Guid replacementGuid = guider.Current;
string replacementText = formatter==null?Replace(m.Value, m.Index, m, foundGuid, replacementGuid, upcase):formatter.ToString(replacementGuid, upcase, false);
if (onReplacement != null) onReplacement(new Replacement() { Line=lineNumber, Column = m.Index, FoundText=m.Value, FoundGuid=foundGuid, ReplacedByText=replacementText, ReplacedByGuid=replacementGuid });
return replacementText;
}
return m.Value;
});
}
return input;
}
public async Task <bool> Connect()
{
ResetGraphValues();
bool connected = false;
try {
if (Guider != null)
{
Guider.PropertyChanged -= Guider_PropertyChanged;
Guider.GuideEvent -= Guider_GuideEvent;
}
_cancelConnectGuiderSource?.Dispose();
_cancelConnectGuiderSource = new CancellationTokenSource();
Guider = GuiderChooserVM.SelectedGuider;
Guider.PropertyChanged += Guider_PropertyChanged;
connected = await Guider.Connect();
_cancelConnectGuiderSource.Token.ThrowIfCancellationRequested();
if (connected)
{
Guider.GuideEvent += Guider_GuideEvent;
GuiderInfo = new GuiderInfo {
Connected = connected
};
BroadcastGuiderInfo();
Notification.ShowSuccess(Locale.Loc.Instance["LblGuiderConnected"]);
RaisePropertyChanged(nameof(Guider));
profileService.ActiveProfile.GuiderSettings.GuiderName = Guider.Name;
}
} catch (OperationCanceledException) {
Guider.PropertyChanged -= Guider_PropertyChanged;
Guider?.Disconnect();
GuiderInfo = new GuiderInfo {
Connected = false
};
BroadcastGuiderInfo();
}
return(connected);
}
public ActionResult DeleteConfirmed(int id)
{
Guider guider = db.Guider.Find(id);
var guider_Schedules = db.Schedule.Where(x => x.guider == guider.Number);
foreach (var item in guider_Schedules)
{
if (item.title == "請假")
{
db.Schedule.Remove(item);
}
else
{
item.guider = "";
}
}
db.Guider.Remove(guider);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void RegressionTest()
{
// Ensure no regression:
// it should be imposible to create entity with the same key
// if old entity is not removed
using (var session = Domain.OpenSession()) {
using (var t = session.OpenTransaction()) {
var id = Guid.NewGuid();
var expected = new Guider(id)
{
Name = "123"
};
AssertEx.Throws <Exception>(() => new Guider(id)
{
Name = "321"
});
var actual = session.Query.All <Guider>().Single();
Assert.AreSame(expected, actual);
Assert.AreEqual("123", actual.Name);
}
}
}
public static IEnumerable<Replacement> ReplaceByLine(System.IO.TextReader reader, System.IO.TextWriter writer, string inputFormat, string outputFormat, Guider guider, bool upcase, bool writeAllInput)
{
IGuidSearcher searcher;
IGuidFormatter formatter = null;
if (!s_SearchesByKey.TryGetValue(inputFormat??"", out searcher)) throw new ArgumentOutOfRangeException("Unrecognized search Type: " + outputFormat);
if (!string.IsNullOrEmpty(outputFormat) && !s_FormatsByKey.TryGetValue(outputFormat, out formatter)) throw new ArgumentOutOfRangeException("Unrecognized output format: " + outputFormat);
int lineCount = 0;
string line;
writer.Write("> ");
while (reader.Peek() != -1 && (line = reader.ReadLine()) != null)
{
List<Replacement> replacements = new List<Replacement>();
string output;
try
{
output = searcher.Replace(line, guider, formatter, upcase, (r)=> { replacements.Add(r); }, lineCount);
if (writeAllInput || replacements.Count > 0)
{
writer.WriteLine(output);
}
}
catch(ArgumentOutOfRangeException orex)
{
Console.WriteLine("Error: " + orex.Message);
}
for(int i = 0; i < replacements.Count; i++) yield return replacements[i];
lineCount++;
writer.Write("> ");
}
}
public phd2()
{
guider = Guider.Factory("localhost");
//guider.Connect();
}
public static int Replace(System.IO.TextReader reader, System.IO.TextWriter writer, Guider guider, Dictionary<Guid, Guid> replacements, string format, bool upcase, bool copyByLine = false)
{
int totalReplacements = 0;
string ucformat = upcase ? "X2" : "x2";
Guid replacement;
string line;
while ((line = reader.ReadLine()) != null)
{
int lc = 0;
MatchCollection mc = s_Parser.Matches(line);
foreach (Match m in mc)
{
lc++;
byte[] bytes = new byte[16];
for (int i = 0; i < 16; i++)
{
byte b;
if (!byte.TryParse(m.Groups["b" + i.ToString()].Value, System.Globalization.NumberStyles.HexNumber, null, out b))
{
if (!m.Success) throw new ArgumentOutOfRangeException();
}
bytes[i] = b;
}
Guid active = new Guid(bytes);
if (!replacements.TryGetValue(active, out replacement))
{
if (!guider.MoveNext(active)) continue;
replacement = guider.Current;
replacements[active] = replacement;
}
if (format == null)
{
byte[] rbytes = replacement.ToByteArray();
for (int i = 0; i < 16; i++)
{
Group g = m.Groups["b" + i.ToString()];
string hex = rbytes[i].ToString(ucformat);
line = line.Substring(0, g.Index) + hex + line.Substring(g.Index + 2);
}
}
else
{
string formattedGuid = GuidFormats.Format(format, replacement, upcase, false);
//replace
line = line.Replace(m.Value, formattedGuid);
}
totalReplacements++;
}
mc = s_B64Parser_Single.Matches(line);
foreach (Match m in mc)
{
lc++;
Guid active = new Guid(Convert.FromBase64String(m.Value));
if (!replacements.TryGetValue(active, out replacement))
{
if (!guider.MoveNext(active)) continue;
replacement = guider.Current;
replacements[active] = replacement;
}
if (format == null)
{
byte[] rbytes = replacement.ToByteArray();
string b64Replacement = Convert.ToBase64String(rbytes);
line = line.Substring(0, m.Index) + b64Replacement + line.Substring(m.Index + m.Length);
}
else
{
string formattedGuid = GuidFormats.Format(format, replacement, upcase, false);
//replace
line = line.Replace(m.Value, formattedGuid);
}
totalReplacements++;
}
if (writer != null) writer.WriteLine(line);
if (copyByLine) System.Windows.Forms.Clipboard.SetData(System.Windows.Forms.DataFormats.Text, line);
}
return totalReplacements;
}
static void Main(string[] args)
{
string host = "localhost";
if (args.Length > 0)
{
host = args[0];
}
try
{
using (Guider guider = Guider.Factory(host))
{
// connect to PHD2
guider.Connect();
// get the list of equipment profiles
foreach (var p in guider.GetEquipmentProfiles())
{
Console.WriteLine("profile: {0}", p);
}
// connect equipment in profile "Simulator"
string profile = "Simulator";
Console.WriteLine("connect profile {0}", profile);
guider.ConnectEquipment(profile);
// start guiding
double settlePixels = 2.0;
double settleTime = 10.0;
double settleTimeout = 100.0;
Console.WriteLine("guide");
guider.Guide(settlePixels, settleTime, settleTimeout);
// wait for settling to complete
WaitForSettleDone(guider);
// monitor guiding for a little while
for (int i = 0; i < 15; i++)
{
GuideStats stats = guider.GetStats();
string state;
double avgDist;
guider.GetStatus(out state, out avgDist);
Console.WriteLine("{0} dist={1:F1} rms={2:F1} ({3:F1}, {4:F1}) peak = {5:F1}, {6:F1}",
state, avgDist,
stats.rms_tot, stats.rms_ra, stats.rms_dec, stats.peak_ra, stats.peak_dec);
System.Threading.Thread.Sleep(1000);
}
// Pause/resume guiding
Console.WriteLine("pause for 5s");
guider.Pause();
System.Threading.Thread.Sleep(5000);
Console.WriteLine("un-pause");
guider.Unpause();
// dither
double ditherPixels = 3.0;
Console.WriteLine("dither");
guider.Dither(ditherPixels, settlePixels, settleTime, settleTimeout);
// wait for settle
WaitForSettleDone(guider);
// stop guiding
Console.WriteLine("stop\n");
guider.StopCapture();
// disconnect from PHD2 (optional in this case since we've got a using() block to take care of it)
guider.Close();
}
}
catch (Exception err)
{
Console.WriteLine("Error: {0}", err.Message);
}
}
