public ActionResult Delete(CourseClass c)
{
CourseList cList = new CourseList();
cList.DeleteCourse(c);
return(RedirectToAction("Index"));
}
// GET: CourseClasses/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CourseClass courseClass = db.CourseClasses.Find(id);
if (courseClass == null)
{
return(HttpNotFound());
}
var selectedLabWorks = courseClass.LabWorks.Select(x => x.Id).ToArray();
var labWorks = db.LabWorks.Select(x => new
{
Id = x.Id,
Value = x.Name
}).ToList();
ViewBag.LabWorks = new MultiSelectList(labWorks, "Id", "Value", selectedLabWorks);
return(View(courseClass));
}
public ActionResult NewCourse(string name, string code)
{
CourseClass course = new CourseClass(name, code);
course.Save();
return(RedirectToAction("Course"));
}
public async Task <CreateCourseClassItemDto> Handle(CreateCourseClassItemCommand request, CancellationToken cancellationToken)
{
var course = await context.Courses
.SingleOrDefaultAsync(l => l.Id.Equals(request.CourseId));
if (course == null)
{
throw new EntityNotFoundException(nameof(Course), request.CourseId);
}
var location = await context.Locations
.SingleOrDefaultAsync(l => l.Id.Equals(request.LocationId));
if (location == null)
{
throw new EntityNotFoundException(nameof(Location), request.LocationId);
}
var entity = new CourseClass()
{
Name = request.Name,
CourseId = course.Id,
LocationId = location.Id,
Capacity = request.Capacity,
};
context.CourseClasses.Add(entity);
await context.SaveChangesAsync(cancellationToken);
return(new CreateCourseClassItemDto
{
Id = entity.Id
});
}
public IActionResult GetClassInformationForStudent([FromQuery] int semester,
[FromQuery] string classCode, [FromQuery] string authToken)
{
// authentication
CourseClass classFromDb = Context.CourseClass
.Include(cc => cc.Course)
.ThenInclude(c => c.Semester)
.Include(cc => cc.Course)
.ThenInclude(c => c.CourseType)
.Include(cc => cc.Timetable)
.Include(cc => cc.Registration)
.ThenInclude(r => r.Student)
.ThenInclude(s => s.AcademicYear)
.Include(cc => cc.Registration)
.ThenInclude(r => r.Student)
.ThenInclude(s => s.Faculty)
.Include(cc => cc.Registration)
.ThenInclude(r => r.Student)
.ThenInclude(s => s.BasicProfile)
.Where(cc => cc.Course.Semester.Id == semester && cc.CourseClassCode == classCode)
.FirstOrDefault();
if (classFromDb is null)
{
return(NoContent());
}
return(Ok(Converter.ForwardConverter(classFromDb)));
}
public async Task <IActionResult> OnPostRemoveStudentAsync(string studentId)
{
CourseClass = await CourseClasses.FindAsync(Id);
if (CourseClass == null)
{
return(NotFound());
}
var student = await Students.FindAsync(studentId);
if (student == null)
{
return(NotFound());
}
if (!await IsStudentInClass(student))
{
return(BadRequest());
}
var studentClass = student.StudentCourseClasses.First(c => c.CourseClassId.Equals(CourseClass.Id));
student.StudentCourseClasses.Remove(studentClass);
Students.Update(student);
await Context.SaveChangesAsync();
return(RedirectToPage(new { id = Id }));
}
public async Task <IActionResult> OnPostAddStudentAsync(string studentId)
{
CourseClass = await CourseClasses.FindAsync(Id);
if (CourseClass == null)
{
return(NotFound());
}
var student = await Students.FindAsync(studentId);
if (student == null)
{
return(NotFound());
}
if (await IsStudentInClass(student))
{
return(BadRequest());
}
student.StudentCourseClasses.Add(
new StudentCourseClass()
{
Class = CourseClass,
Student = student
});
Students.Update(student);
await Context.SaveChangesAsync();
return(RedirectToPage(new { id = Id }));
}
public ActionResult Edit(CourseClass c)
{
CourseList cList = new CourseList();
cList.UpdateCourse(c);
return(RedirectToAction("Index"));
}
public void AddEditDel_CourseClass(DO_CourseClass objClass, CourseClass flag)
{
SqlConnection conn = new SqlConnection();
SQLManager co = new SQLManager();
conn = co.GetConnection();
cmd = new SqlCommand("Scrl_AddEditDelCourseClassDetail", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@FlagNo", SqlDbType.Int).Value = flag;
cmd.Parameters.Add("@CourseDetailId", SqlDbType.BigInt).Value = objClass.CourseDetailId;
cmd.Parameters.Add("@ClassId", SqlDbType.BigInt).Value = objClass.ClassId;
cmd.Parameters.Add("@FromClassId", SqlDbType.BigInt).Value = objClass.FromClassId;
cmd.Parameters.Add("@CourseId", SqlDbType.BigInt).Value = objClass.CourseId;
cmd.Parameters.Add("@StudentIds", SqlDbType.VarChar, 200).Value = objClass.StudentIds;
cmd.Parameters.Add("@BatchYear", SqlDbType.VarChar, 200).Value = objClass.BatchYear;
cmd.Parameters.Add("@PassingYear", SqlDbType.VarChar, 200).Value = objClass.PassingYear;
cmd.Parameters.Add("@ParentId", SqlDbType.BigInt).Value = objClass.ParentId;
cmd.Parameters.Add("@AddedBy", SqlDbType.BigInt).Value = objClass.AddedBy;
cmd.Parameters.Add("@ModifiedBy", SqlDbType.BigInt).Value = objClass.ModifiedBy;
cmd.Parameters.Add("@IPAddress", SqlDbType.VarChar, 200).Value = objClass.IpAddress;
cmd.ExecuteNonQuery();
co.CloseConnection(conn);
}
private void Save(Schedule schedule)
{
int numberOfRooms = Configuration.GetInstance.GetNumberOfRooms();
int daySize = schedule.day_Hours * numberOfRooms;
var db = new LINQDataContext();
db.Classroom_TimeDeleteAll();
foreach (KeyValuePair <CourseClass, int> it in schedule.GetClasses().ToList())
{
// coordinate of time-space slot
int pos = it.Value; // int pos of _slot array
int day = pos / daySize;
int time = pos % daySize; // this is not time now!
int room = time / schedule.day_Hours;
time = time % schedule.day_Hours; // this is a time now!
int dur = it.Key.GetDuration;
CourseClass cc = it.Key;
Algorithm.Room r = Configuration.GetInstance.GetRoomById(room);
//
// Save Classroom_Time
//
db.Classroom_TimeSave(r.Origin_ID_inDB, cc.Class_ID, cc.GetProfessor.GetId, time, dur, day);
//
// Save New_GroupsPerClassroom
//
foreach (var gs in cc.GetGroups)
{
db.New_GroupsPerClassSave(r.Origin_ID_inDB, cc.Class_ID, time, day, gs.GetId);
}
}
}
public async Task <IActionResult> OnGetAsync()
{
CourseClass = await CourseClasses.FindAsync(Id);
if (CourseClass == null)
{
return(NotFound());
}
var type = (SurveyQuestion.SurveyQuestionTypes)Type;
switch (type)
{
case SurveyQuestion.SurveyQuestionTypes.Qualitative:
Question = new SurveyQuestionQualitative();
break;
case SurveyQuestion.SurveyQuestionTypes.Rate:
Question = new SurveyQuestionRate();
break;
default:
throw new ArgumentOutOfRangeException();
}
return(Page());
}
public CourseAndClassList(CourseInfo courseInfo, CourseClass courseClass, String courseName)
{
this.courseInfo = courseInfo;
courseClasses = new List <CourseClass>();
this.courseClasses.Add(courseClass);
this.courseName = courseName;
}
public async Task <IActionResult> Create(CourseClassViewModel model) //[Bind("Id,Title,CourseId")] CourseClass courseClass
{
var courseClass = new CourseClass
{
Title = model.Title,
CourseId = model.CourseId
};
courseClass.CourseClassDay = new List <CourseClassDay>();
model.Days.ToList().ForEach(item =>
{
courseClass.CourseClassDay.Add(new CourseClassDay
{
Day = (Days)item.DayId,
StartTime = item.StartTime,
FinishTime = item.FinishTime
});
});
await _context.AddAsync(courseClass);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
//if (ModelState.IsValid)
//{
// _context.Add(courseClass);
// await _context.SaveChangesAsync();
// return RedirectToAction(nameof(Index));
//}
//ViewData["CourseId"] = new SelectList(_context.Courses, "Id", "Title", courseClass.CourseId);
//return View(courseClass);
// return View();
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,CourseId")] CourseClass courseClass)
{
if (id != courseClass.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(courseClass);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseClassExists(courseClass.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CourseId"] = new SelectList(_context.Courses, "Id", "Title", courseClass.CourseId);
return(View(courseClass));
}
public async Task <IActionResult> CreateAjax(CourseClassViewModel model) //[Bind("Id,Title,CourseId")] CourseClass courseClass
{
System.Threading.Thread.Sleep(4000);
var courseClass = new CourseClass
{
Title = model.Title,
CourseId = model.CourseId
};
courseClass.CourseClassDay = new List <CourseClassDay>();
model.Days.ToList().ForEach(item =>
{
courseClass.CourseClassDay.Add(new CourseClassDay
{
Day = (Days)item.DayId,
StartTime = item.StartTime,
FinishTime = item.FinishTime
});
});
await _context.AddAsync(courseClass);
await _context.SaveChangesAsync();
var result = new AjaxActionResult <CourseClass>();
result.IsSuccess = true;
result.Message = "success...";
return(Ok(result));
}
public void SetSchedule(Schedule schedule, bool showGraphical)
{
_schedule = schedule.MakeCopy(false);
if (Monitor.TryEnter(Locker, 500))
{
//_resultWindow.Controls["lblFitness"].Text = schedule.GetFitness().ToString();
SetText("Fitness: " + schedule.GetFitness().ToString());
Monitor.Exit(Locker);
}
else
{
return;
}
if (showGraphical)
{
//
// ReSet to New DataGridView
//
foreach (KeyValuePair <int, DataGridView> it in dgvList)
{
ClearDataGridView(it.Value);
}
//
int numberOfRooms = Configuration.GetInstance.GetNumberOfRooms();
int daySize = schedule.day_Hours * numberOfRooms;
Random rand = new Random();
foreach (KeyValuePair <CourseClass, int> it in schedule.GetClasses().ToList())
{
// coordinate of time-space slot
int pos = it.Value; // int pos of _slot array
int day = pos / daySize;
int time = pos % daySize; // this is not time now!
int room = time / schedule.day_Hours;
time = time % schedule.day_Hours; // this is a time now!
int dur = it.Key.GetDuration;
CourseClass cc = it.Key;
Room r = Configuration.GetInstance.GetRoomById(room);
string groups_Name = "";
foreach (var gs in cc.GetGroups)
{
groups_Name += gs.GetName + "\r\n";
}
groups_Name = groups_Name.Trim();
((DataGridViewTextBoxCellEx)dgvList[r.GetId][day + 1, time]).RowSpan = cc.GetDuration;
dgvList[r.GetId][day + 1, time].Style.BackColor =
Color.FromArgb(rand.Next(70, 250), rand.Next(70, 250), rand.Next(70, 250));
dgvList[r.GetId][day + 1, time].Value = string.Format(CultureInfo.CurrentCulture,
"{0}\r\n{1}\r\n{2}\r\n{3}", cc.GetCourse.GetName, cc.GetProfessor.GetName, groups_Name, cc.Lab);
//(cc.GetCourse.GetName + Environment.NewLine +
// cc.GetProfessor.GetName + Environment.NewLine +
// groups_Name + Environment.NewLine + cc.Lab);
}
}
}
public ActionResult DeleteConfirmed(int id)
{
CourseClass courseClass = db.CourseClasses.Find(id);
db.CourseClasses.Remove(courseClass);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
CourseClass courseClass = await db.CourseClass.FindAsync(id);
db.CourseClass.Remove(courseClass);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public ResultEntity addClass(CourseClass courseClass)
{
ResultEntity resultEntity = new ResultEntity();
resultEntity.setState(courseService.addClass(courseClass));
resultEntity.setData(courseClass);
resultEntity.setMessage(resultEntity.getState() == 1 ? "新增班级成功！" : "该班级已经存在！");
return(resultEntity);
}
public ActionResult ShowCourse(int id)
{
Dictionary <string, object> allInfo = new Dictionary <string, object>();
List <StudentClass> students = JoinTableClass.GetStudentsByCourseId(id);
List <CourseClass> course = CourseClass.FindById(id);
allInfo.Add("students", students);
allInfo.Add("course", course);
return(View("ShowCourse", allInfo));
}
public static CourseClassDTO ToDTO(this CourseClass cl)
{
return(new CourseClassDTO()
{
Id = cl.Id,
CourseId = cl.CourseId,
Date = cl.Date,
Description = cl.Description
});
}
public ActionResult Edit([Bind(Include = "Id,Name,Description,StartTime,EndTime")] CourseClass courseClass)
{
if (ModelState.IsValid)
{
db.Entry(courseClass).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(courseClass));
}
public ActionResult AssignCourses()
{
Dictionary <string, object> allInfo = new Dictionary <string, object>();
List <CourseClass> courses = CourseClass.GetAll();
List <DepartmentClass> departments = DepartmentClass.GetAll();
allInfo.Add("courses", courses);
allInfo.Add("departments", departments);
return(View(allInfo));
}
public ActionResult Create(CourseClass c)
{
if (ModelState.IsValid)
{
CourseList cList = new CourseList();
cList.AddCourse(c);
return(RedirectToAction("Index"));
}
return(View());
}
public ActionResult Assign()
{
Dictionary <string, object> allInfo = new Dictionary <string, object>();
List <StudentClass> students = StudentClass.GetAll();
List <CourseClass> courses = CourseClass.GetAll();
allInfo.Add("students", students);
allInfo.Add("courses", courses);
return(View(allInfo));
}
public async Task <IActionResult> OnGetAsync()
{
CourseClass = await CourseClasses.FindAsync(Id);
if (CourseClass == null)
{
return(NotFound());
}
return(Page());
}
public ActionResult Create([Bind(Include = "Id,Name,Description,IsOpened")] CourseClass courseClass)
{
if (ModelState.IsValid)
{
db.CourseClasses.Add(courseClass);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(courseClass));
}
private static CourseClass CreateCourseClass()
{
Teacher teacher = new Teacher();
Console.WriteLine("Name Teacher:");
teacher.Name = Console.ReadLine();
Console.WriteLine("Lastmame Teacher:");
teacher.LastName = Console.ReadLine();
Console.WriteLine("Year of Birth:");
int year = Convert.ToInt16(Console.ReadLine());
Console.WriteLine("Month of Birth (1....12):");
int month = Convert.ToInt16(Console.ReadLine());
Console.WriteLine("Day of Birth (1....12):");
int day = Convert.ToInt16(Console.ReadLine());
teacher.DateofBirth = new DateTime(year, month, day);
Console.WriteLine("Courses seperated by ';'");
string[] courses = Console.ReadLine().Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
foreach (string course in courses)
{
teacher.Courses.Add(new Course()
{
Name = course
});
}
ClassRoom room = new ClassRoom();
Console.WriteLine("Room Floor:");
room.Floor = Convert.ToInt16(Console.ReadLine());
Console.WriteLine("Room Number:");
room.Number = Convert.ToInt16(Console.ReadLine());
Console.WriteLine("Room Size:");
room.Size = Convert.ToInt16(Console.ReadLine());
Console.WriteLine("Amount of machines:");
room.AmountMachines = Convert.ToInt16(Console.ReadLine());
CourseClass courseClass = new CourseClass(teacher);
courseClass.Room = room;
return(courseClass);
}
public async Task <ActionResult> AddClass(CourseClassInsertDTO courseClass)
{
CourseClass newClass = new CourseClass()
{
CourseId = courseClass.CourseId,
Description = courseClass.Description,
Date = DateTime.Now
};
var classId = await _courseRepository.AddClass(newClass);
if (classId != 0)
{
List <StudentCourse> stdCourses = await _courseRepository.GetStudentCoursesByCourseid(courseClass.CourseId);
List <StudentAttendance> studentAttendances = new List <StudentAttendance>();
foreach (var item in stdCourses)
{
bool attended = false;
foreach (var id in courseClass.StudentIds)
{
if (item.StudentId == id)
{
StudentAttendance sa = new StudentAttendance()
{
CourseClassId = classId,
StudentCourseId = item.Id,
Present = true
};
studentAttendances.Add(sa);
attended = true;
}
}
if (attended == false)
{
StudentAttendance sa = new StudentAttendance()
{
CourseClassId = classId,
StudentCourseId = item.Id,
Present = false
};
studentAttendances.Add(sa);
}
}
_studentRepository.AddStudentAttendance(studentAttendances);
return(Ok());
}
return(BadRequest());
}
public CourseAndClass(CourseInfo courseInfo, CourseClass courseClass)
{
CourseInfo temp = courseInfo;
Regex regExp = new Regex(@"^\d+$");
if (regExp.IsMatch(courseInfo.courseName))
{
temp.courseName = (new CourseServiceImp().getCourseNameByNameID(int.Parse(courseInfo.courseName)).courseName);
}
this.courseInfo = temp;
this.courseClass = courseClass;
this.courseNameID = courseInfo.courseName;
}
public static string insert_courseClass(CourseClass courseClass)
{
SqlConnection con = new SqlConnection(GetConnectionString());
string ins = "INSERT INTO Courses"
+ " (Course_ID, Course_Name, Course_Description, Course_EnrollmentKey, Course_Owner ) "
+ " VALUES( @OCourse_ID, @Course_Name, @Course_Description, @Course_EnrollmentKey, @Course_Owner)";
SqlCommand cmd = new SqlCommand(ins, con);
cmd.Parameters.AddWithValue("Course_ID", courseClass.Course_ID);
cmd.Parameters.AddWithValue("Course_Name", courseClass.Course_Name);
cmd.Parameters.AddWithValue("Course_Description", courseClass.Course_Description);
cmd.Parameters.AddWithValue("Course_EnrollmentKey", courseClass.Course_EnrollmentKey);
cmd.Parameters.AddWithValue("Course_Owner", courseClass.Course_Owner);
con.Open();
int i = cmd.ExecuteNonQuery();
con.Close();
return courseClass.Course_ID;
}
public static int delete_Course(CourseClass courseClass)
{
SqlConnection con = new SqlConnection(GetConnectionString());
string del = "DELETE FROM Courses "
+ "WHERE Course_ID = @Course_ID "
+ "AND Course_Name = @Course_Name "
+ "AND Course_Description = @Course_Description "
+ "AND Course_EnrollmentKey = @Course_EnrollmentKey "
+ "AND Course_Owner = @Course_Owner";
SqlCommand cmd = new SqlCommand(del, con);
cmd.Parameters.AddWithValue("Course_ID", courseClass.Course_ID);
cmd.Parameters.AddWithValue("Course_Name", courseClass.Course_Name);
cmd.Parameters.AddWithValue("Course_Description", courseClass.Course_Description);
cmd.Parameters.AddWithValue("Course_EnrollmentKey", courseClass.Course_EnrollmentKey);
cmd.Parameters.AddWithValue("Course_Owner", courseClass.Course_Owner);
con.Open();
int i = cmd.ExecuteNonQuery();
con.Close();
return i;
}
public static List<CourseClass> GetCourses()
{
List<CourseClass> courseList = new List<CourseClass>();
SqlConnection con = new SqlConnection(GetConnectionString());
string sel = "SELECT Course_ID, Course_Name, Course_Description, Course_EnrollmentKey, Course_Owner "
+ "FROM Courses ORDER BY Course_ID desc";
SqlCommand cmd = new SqlCommand(sel, con);
con.Open();
SqlDataReader dr =
cmd.ExecuteReader(CommandBehavior.CloseConnection);
CourseClass courseClass;
while (dr.Read())
{
courseClass = new CourseClass();
courseClass.Course_ID = dr["Course_ID"].ToString();
courseClass.Course_Name = dr["Course_Name"].ToString();
courseClass.Course_Description = dr["Course_Description"].ToString();
courseClass.Course_EnrollmentKey = dr["Course_EnrollmentKey"].ToString();
courseClass.Course_Owner = dr["Course_Owner"].ToString();
courseList.Add(courseClass);
}
dr.Close();
return courseList;
}
public static int update_Course(CourseClass original_courseClass, CourseClass courseClass)
{
SqlConnection con = new SqlConnection(GetConnectionString());
string up = "UPDATE Courses "
+ "SET Course_ID = @Course_ID, "
+ "SET Course_Name = @Course_Name, "
+ "SET Course_Description = @Course_Description "
+ "SET Course_EnrollmentKey = @Course_EnrollmentKey "
+ "SET Course_Owner = @Course_Owner "
+ "Where Course_ID = @origional_Course_ID "
+ "AND Course_Name = @original_Course_Name "
+ "AND Course_Description = @original_Course_Description "
+ "AND Course_EnrollmentKey = @origional_Course_EnrollmentKey "
+ "AND Course_Owner = @origional_Course_Owner ";
SqlCommand cmd = new SqlCommand(up, con);
// cmd.Parameters.AddWithValue("Order_ID", order.Order_ID);
cmd.Parameters.AddWithValue("Course_ID", courseClass.Course_ID);
cmd.Parameters.AddWithValue("Course_Name", courseClass.Course_Name);
cmd.Parameters.AddWithValue("Course_Description", courseClass.Course_Description);
cmd.Parameters.AddWithValue("Course_EnrollmentKey", courseClass.Course_EnrollmentKey);
cmd.Parameters.AddWithValue("Course_Owner", courseClass.Course_Owner);
///////ORIGINAL PARAMS///////////////////////////////////
cmd.Parameters.AddWithValue("original_Course_ID",original_courseClass.Course_ID);
cmd.Parameters.AddWithValue("original_Course_Name", original_courseClass.Course_Name);
cmd.Parameters.AddWithValue("original_Course_Description",original_courseClass.Course_Description);
cmd.Parameters.AddWithValue("original_Course_EnrollmentKey", original_courseClass.Course_EnrollmentKey);
cmd.Parameters.AddWithValue("original_Course_Owner", original_courseClass.Course_Owner);
con.Open();
int updateCount = cmd.ExecuteNonQuery();
con.Close();
return updateCount;
}
public static string return_CourseID(CourseClass courseClass)
{
SqlConnection con = new SqlConnection(GetConnectionString());
string sel = "SELECT top(1) Course_ID"
+ "FROM Courses Order by Course_ID desc";
SqlCommand cmd = new SqlCommand(sel, con);
con.Open();
SqlDataReader dr =
cmd.ExecuteReader(CommandBehavior.CloseConnection);
// Order order;
String retOrder_id = "";
while (dr.Read())
{
retOrder_id = dr["Course_ID"].ToString(); // RETURNING NULL HERE
}
dr.Close();
return retOrder_id;
}
protected override void BuildCurveEntry()
{
try
{
int cntr, incr;
incr = 1;
cntr = 0;
double wholeNumChords = Math.Floor(m_numChords);
m_pCourseArray = new CourseClass[m_coursecount];
ICourse pCourse;
double increm = 1; // we start with whole increments of one
const double centralAngleIncremDD = 10.0 / 60;
double lastDeltaAngleDD = 0;
double lastbearingDD = 0;
for(double N = 1; N <= wholeNumChords; N++)
{
//calculate central angle (of circle chord)
double centralAngleDD = N * centralAngleIncremDD;
Debug.WriteLine("Central Angle = " + (centralAngleDD * 60) + " DD");
// calculate opposite angles in triangle (isoceles)
double deltaAngleDD = 90.0 - (90.0 - (centralAngleDD / 2.0));
Debug.WriteLine("Delta Angle = " + deltaAngleDD + " DD");
Debug.WriteLine("Delta Angle = " + Math.Round((deltaAngleDD * 60),2) + " Min");
// add new delta angle to the last delta to get the deflection angle (from last course)
double deflectionAngleDD = deltaAngleDD + lastDeltaAngleDD;
Debug.WriteLine("Deflection Angle = " + deflectionAngleDD + " DD");
Debug.WriteLine("Deflection Angle = " + Math.Round((deflectionAngleDD * 60),2) + " Min");
// update delta for next loop
lastDeltaAngleDD = deltaAngleDD;
// with each loop we inrement the bearing by the current deflection angle
lastbearingDD += deflectionAngleDD;
Debug.WriteLine("Bearing = " + Math.Round((lastbearingDD * 60),2) + " Min");
// finally: calculate the course bearing WRT the tangent bearing
double bearingRad = utils.Deg2Rad(lastbearingDD);
// default turn direction if left (with above calculations)
// if we are making a right turn, adjust the angle to mirror the left curve
if (m_turnDirec == esriTurnDirection.esriTDLeft)
{
bearingRad -= (2 * bearingRad);
}
double newBearingRad = m_tangentAngle - bearingRad ;
double newBearingDD = utils.Rad2Deg(newBearingRad);
// create and populate a ne direction-distance course and add it the array of courses
pCourse = new CourseClass();
pCourse.Type = ESRI.ArcGIS.Editor.esriCourseType.esriCTDirectionDistance;
pCourse.Measure1 = newBearingRad; // newBearingDD;
pCourse.Measure2 = m_chordLength;
m_pCourseArray[cntr] = new CourseClass();
m_pCourseArray[cntr] = pCourse;
cntr += incr;
Debug.WriteLine("");
}
//calculate angle for fractional (short) chords lengths
increm = m_numChords % wholeNumChords; //get modulus for last increment (to be used for partial chord)
if (increm > 0)
{
double N = Math.Ceiling(m_numChords);
//calculate central angle (of circle chord)
double centralAngleDD = N * centralAngleIncremDD;
Debug.WriteLine("Central Angle = " + (centralAngleDD * 60) + " DD");
// calculate opposite angles in triangle (isoceles)
double deltaAngleDD = 90.0 - (90.0 - (centralAngleDD / 2.0));
Debug.WriteLine("Delta Angle = " + deltaAngleDD + " DD");
Debug.WriteLine("Delta Angle = " + Math.Round((deltaAngleDD * 60),2) + " Min");
// add new delta angle to the last delta to get the deflection angle (from last course)
double deflectionAngleDD = deltaAngleDD + lastDeltaAngleDD;
Debug.WriteLine("Deflection Angle = " + deflectionAngleDD + " DD");
Debug.WriteLine("Deflection Angle = " + Math.Round((deflectionAngleDD * 60),2) + " Min");
// update delta for next loop
lastDeltaAngleDD = deltaAngleDD;
// with each loop we inrement the bearing by the current deflection angle
lastbearingDD += deflectionAngleDD;
Debug.WriteLine("Bearing = " + Math.Round((lastbearingDD * 60),2) + " Min");
// finally: calculate the course bearing WRT the tangent bearing
double bearingRad = utils.Deg2Rad(lastbearingDD);
// default turn direction if left (with above calculations)
// if we are making a right turn, adjust the angle to mirror the left curve
if (m_turnDirec == esriTurnDirection.esriTDLeft)
{
bearingRad -= (2 * bearingRad);
}
double newBearingRad = m_tangentAngle - bearingRad ;
double newBearingDD = utils.Rad2Deg(newBearingRad);
// create and populate a ne direction-distance course and add it the array of courses
pCourse = new CourseClass();
pCourse.Type = ESRI.ArcGIS.Editor.esriCourseType.esriCTDirectionDistance;
pCourse.Measure1 = newBearingRad; // newBearingDD;
pCourse.Measure2 = m_chordLength * (m_numChords - wholeNumChords) ;
m_pCourseArray[cntr] = new CourseClass();
m_pCourseArray[cntr] = pCourse;
cntr += incr;
Debug.WriteLine("");
}
}
catch(Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
protected override void BuildCurveExit()
{
try
{
// array storage counter and incrementer
int cntr, incr;
incr = -1;
cntr = m_coursecount-1;
m_tangentAngle -= Math.PI;
Debug.WriteLine("tangent angle = " + utils.Rad2Deg(m_tangentAngle));
double wholeNumChords = Math.Floor(m_numChords);
m_pCourseArray = new CourseClass[m_coursecount];
ICourse pCourse;
double increm = 1; // we start with whole increments of one
double angleMin, angleDD, angleRad;
//calculate angles for whole (short) chord lengths
for(double N = 0; N < wholeNumChords; N++)
{
// spiral curve calculation -> produces an angle in minutes
angleMin = (m_chordLength / (10.0 * increm)) * (Math.Pow((double)(N+1),3.0) - Math.Pow(N,3.0));
Debug.WriteLine(N + " " + angleMin + " " + utils.MinToDD(angleMin));
angleDD = utils.MinToDD(angleMin);
angleRad = utils.Deg2Rad(angleDD);
// default turn direction is right (with above calculations)
// if we are making a left turn, adjust the angle to mirror the right curve
if (m_turnDirec == esriTurnDirection.esriTDLeft)
{
angleRad -= (2 * angleRad);
}
double newAngleRad;
newAngleRad = angleRad + m_tangentAngle;
double newAngleDD = utils.Rad2Deg(newAngleRad);
// create and populate a ne direction-distance course and add it the array of courses
pCourse = new CourseClass();
pCourse.Type = ESRI.ArcGIS.Editor.esriCourseType.esriCTDirectionDistance;
pCourse.Measure1 = newAngleRad; // newAngleDD;
pCourse.Measure2 = m_chordLength;
m_pCourseArray[cntr] = new CourseClass();
m_pCourseArray[cntr] = pCourse;
cntr += incr;
}
//calculate angle for fractional (short) chords lengths
increm = m_numChords % wholeNumChords; //get modulus for last increment (to be used for partial chord)
if (increm > 0)
{
// spiral curve calculation -> produces an angle in minutes
angleMin = (m_chordLength / (10.0 * increm)) * (Math.Pow((wholeNumChords + increm ),3.0) - Math.Pow(wholeNumChords,3.0));
Debug.WriteLine(wholeNumChords + " " + angleMin + " " + utils.MinToDD(angleMin));
angleDD = utils.MinToDD(angleMin);
angleRad = utils.Deg2Rad(angleDD);
// default turn direction is right (with above calculations)
// if we are making a right turn, adjust the angle to mirror the right curve
if (m_turnDirec == esriTurnDirection.esriTDLeft)
{
angleRad -= (2 * angleRad);
}
// add the tangent angle of the existing geometry to the calculated angle
double newAngleRad = angleRad + m_tangentAngle;
double newAngleDD = utils.Rad2Deg(newAngleRad);
// create and populate a ne direction-distance course and add it the array of courses
pCourse = new CourseClass();
pCourse.Type = ESRI.ArcGIS.Editor.esriCourseType.esriCTDirectionDistance;
pCourse.Measure1 = newAngleRad; // newAngleDD;
pCourse.Measure2 = m_chordLength * (m_numChords - wholeNumChords); //fractional chord length
m_pCourseArray[cntr] = new CourseClass();
m_pCourseArray[cntr] = pCourse;
cntr += incr;
}
}
catch(Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
