private void SetupAnswerKey()
{
if (rowIndex >= dgv.Rows.Count || dgv.Rows[rowIndex].Tag == null)
{
return;
}
IRecognitionForm form = (IRecognitionForm)dgv.Rows[rowIndex].Tag;
string guid = form.Id;
string fileName = workspace.AnswerKeyPath;
lblFilename.Text = LBL_FILENAME + Path.GetFileName(fileName);
if (File.Exists(fileName))
{
masterSheet = workspace.ImageManager.Get(guid);
SetupAnnotations(masterSheet);
}
else
{
Label lbl = new Label();
lbl.TextAlign = ContentAlignment.MiddleCenter;
lbl.Text = string.Format("The image file for the answer key \n\"{0}\"\n was not found.", fileName);
spltMain.Panel2.Controls.Add(lbl);
lbl.AutoSize = false;
lbl.Dock = DockStyle.Fill;
lbl.BringToFront();
}
Workspace.ReviewCounter rc = Workspace.GetManualReviewCollection(form, workspace.VerificationParameters, workspace.Answers);
}
protected override void Run()
{
int ticker = 0;
int step = Math.Max(100 / ((forms == null || forms.Count == 0 ? 1 : forms.Count) + (answers == null ? 0 : 1)), 1);
AnswerReviewCount = new Workspace.ReviewCounter();
ResultsReviewCount = new Workspace.ReviewCounter();
if (answers != null)
{
Progress(ticker += step, "Analyzing key...");
AnswerReviewCount = Workspace.GetManualReviewCollection(answers, verificationParameters);
}
if (forms == null || forms.Count == 0)
{
return;
}
for (int i = 0; i < forms.Count; i++)
{
IRecognitionForm form = forms[i];
Progress(ticker += step, string.Format("Analyzing {0}...", form.Name));
ResultsReviewCount += Workspace.GetManualReviewCollection(form, verificationParameters, answers);
}
base.Run();
}
private void PopulateFileDropdown()
{
int startingRowIndex = rowIndex;
// first, back up to the first row containing a worksheet
while (startingRowIndex >= 0 && dgv.Rows[startingRowIndex].Tag != null)
{
startingRowIndex--;
}
startingRowIndex++;
IRecognitionForm startingForm = dgv.Rows[rowIndex].Tag as IRecognitionForm;
cbFiles.DisplayMember = "Name";
// iterate over each worksheet and add to dropdown
while (dgv.Rows[startingRowIndex].Tag != null)
{
IRecognitionForm form = (IRecognitionForm)dgv.Rows[startingRowIndex].Tag;
cbFiles.Items.Add(form);
startingRowIndex++;
}
cbFiles.SelectedItem = startingForm;
}
public GradeOperation(IRecognitionForm answerKey, List <IRecognitionForm> toGrade, int passingGrade)
{
this.answers = answerKey;
this.results = toGrade;
this.passingScore = passingGrade;
useWaitWindow = false;
}
public void ReprocessVerification(VerificationParameters parameters, IRecognitionForm ans, List <IRecognitionForm> res)
{
extractor = new ExtractReviewCollectionOperation(answers, results, verificationParameters);
extractor.Start();
this.answerReviewCounts = extractor.AnswerReviewCount;
this.resultReviewCounts = extractor.ResultsReviewCount;
}
public ExtractReviewCollectionOperation(IRecognitionForm answers, List <IRecognitionForm> forms, VerificationParameters verificationParameters) : base()
{
this.answers = answers;
this.forms = forms;
this.verificationParameters = verificationParameters;
useWaitWindow = false;
}
public void Process()
{
omrProcessor.Start();
this.template = omrProcessor.TemplateForm;
this.answers = omrProcessor.Answers;
this.results = omrProcessor.Results;
ReprocessVerification(VerificationParameters.AllParameters, answers, results);
}
public void InitializeDefaults()
{
imageManager = new MemoryImageManager();
myImages = new Dictionary <string, string>();
template = MainForm.GetOmrEngine().CreateTemplateForm();
answers = MainForm.GetOmrEngine().CreateRecognitionForm();
results = new List <IRecognitionForm>();
}
protected override void Run()
{
bool checkAnswers = key != null;
int ticker = 0;
int step = toLoad == null ? 101 : Math.Max(100 / (toLoad.Count + 2), 1);
Progress(ticker += step, "Initializing objects");
if (checkAnswers)
{
Progress(ticker += step, "Recognizing key");
try
{
answers = RecognizeForm(key, Workspace.IMGMGR_ANSWERS, Workspace.IMGMGR_ANSWERS);
}
catch (Exception)
{
errorList.Add(Workspace.IMGMGR_ANSWERS);
answers = null;
}
}
results = new List <IRecognitionForm>();
if (toLoad != null)
{
foreach (KeyValuePair <string, string> kvp in toLoad)
{
string imageKey = kvp.Key;
string fname = System.IO.Path.GetFileNameWithoutExtension(kvp.Value);
Progress(ticker += step, string.Format("Recognizing {0}", fname));
using (RasterImage image = imageManager.Get(imageKey))
{
try
{
IRecognitionForm frm = RecognizeForm(image, imageKey, fname);
results.Add(frm);
}
catch (Exception)
{
errorList.Add(fname);
}
}
}
}
base.Run();
}
public void UpdateAnswerKey(KeyPanel pid)
{
if (pid.AnswerImage != null)
{
imageManager.Add(Workspace.IMGMGR_ANSWERS, pid.AnswerImagePath);
myAnswerkeyPath = pid.AnswerImagePath;
}
ProcessOmrDocumentsOperation podo = new ProcessOmrDocumentsOperation(pid.AnswerImage, template, this.imageManager, null);
podo.Start();
this.answers = podo.Answers;
ReprocessVerification(VerificationParameters.AllParameters, answers, results);
}
private void DoWorksheetSetup(IRecognitionForm form)
{
if (rowIndex >= dgv.Rows.Count || dgv.Rows[rowIndex].Tag == null)
{
return;
}
string guid = form.Id;
string fileName = workspace.GetImageFilePath(guid);
Workspace.ReviewCounter rc = Workspace.GetManualReviewCollection(form, workspace.VerificationParameters, workspace.Answers);
masterSheet = workspace.ImageManager.Get(guid);
SetupAnnotations(masterSheet);
}
private void cbFiles_SelectedIndexChanged(object sender, EventArgs e)
{
IRecognitionForm selectedForm = (IRecognitionForm)cbFiles.SelectedItem;
if (selectedForm == null)
{
return;
}
for (int i = 0; i < dgv.Rows.Count; i++)
{
if (dgv.Rows[i].HeaderCell.Value != null && dgv.Rows[i].HeaderCell.Value.ToString() == selectedForm.Name)
{
rowIndex = i;
break;
}
}
DoWorksheetSetup(selectedForm);
DoZoneSetup();
UpdateNavigationEnables();
}
private IRecognitionForm RecognizeForm(RasterImage formImage, string id, string name)
{
IRecognitionForm recognizeForm = MainForm.GetOmrEngine().CreateRecognitionForm();
for (int i = 0; i < formImage.PageCount; i++)
{
formImage.Page = i + 1;
DeskewCommand dskcmd = new DeskewCommand();
dskcmd.FillColor = Leadtools.RasterColor.White;
dskcmd.Flags = DeskewCommandFlags.DoNotUseCheckDeskew;
dskcmd.Run(formImage);
recognizeForm.Pages.AddPage(formImage);
}
recognizeForm.Recognize(_templateForm);
recognizeForm.Id = id;
recognizeForm.SaveEmbeddedImage = false;
recognizeForm.Name = name;
return(recognizeForm);
}
public static ReviewCounter GetManualReviewCollection(IRecognitionForm recognizeForm, VerificationParameters parameters, IRecognitionForm answers = null, bool[][][] reviewed = null)
{
ReviewCounter reviewCounter = new ReviewCounter();
for (int i = 0; i < recognizeForm.Pages.Count; i++)
{
Page page = recognizeForm.Pages[i];
for (int j = 0; j < page.Fields.Count; j++)
{
Field field = page.Fields[j];
if (field == null)
{
continue;
}
field.PageNumber = page.PageNumber;
OmrField omrField = field as OmrField;
if (omrField != null)
{
for (int k = 0; k < omrField.Fields.Count; k++)
{
OmrCollection omr = omrField.Fields[k];
reviewCounter.TotalCounts++;
//string errors = "The field confidence value is below the required confidence value, the field does not have exactly one bubble filled in, the field has the same value as the answer key, the field has a different value from the answer key, ";
List <string> errors = new List <string>();
VerificationParameters erroredParams = new VerificationParameters(false, false, false, false, parameters.Threshold, false, false);
ReviewParameters rp = null;
if (omr.Tag != null)
{
rp = (ReviewParameters)omr.Tag;
erroredParams = rp.ErroredParameters;
}
string answerVals = null;
erroredParams.Threshold = omr.Confidence;
if (/* parameters.UseThreshold && */ omr.Confidence < parameters.Threshold)
{
errors.Add("OMR confidence value too low");
erroredParams.UseThreshold = true;
reviewCounter.BelowThreshold++;
}
// if (parameters.UseExactlyOneBubble)
{
int selectedCells = omr.Fields.Count <OmrBubble>(delegate(OmrBubble bub) { return(bub.IsChecked); });
if (selectedCells != 1)
{
errors.Add("Does not have exactly one bubble filled in");
erroredParams.UseExactlyOneBubble = true;
reviewCounter.NotExactlyOneBubble++;
}
}
erroredParams.UseValueChanged = omr.Value != omr.OriginalValue;
if (answers != null && answers.Pages.Count > 0)
{
OmrField ansField = answers.Pages[i].Fields[j] as OmrField;
OmrFieldResult ofr = (OmrFieldResult)ansField.Result;
string value = ansField.Fields[k].Value;
answerVals = value;
if (/* parameters.UseAgreeWithKey && */ omr.Value == value)
{
errors.Add("Same value as answer key");
erroredParams.UseAgreeWithKey = true;
reviewCounter.AgreeWithKey++;
}
if (/* parameters.UseDisagreeWithKey && */ omr.Value != value)
{
errors.Add("Different value from answer key");
erroredParams.UseDisagreeWithKey = true;
reviewCounter.DisagreeWithKey++;
}
}
//page.Image.Page = omrField.PageNumber + 1;
if (rp != null)
{
rp.ErroredParameters = erroredParams;
omr.Tag = rp;
}
else
{
omr.Tag = new ReviewParameters(omrField.GetValues(), errors, answerVals, recognizeForm.Id, erroredParams, page.PageNumber);
}
if (errors.Count > 0)
{
if (reviewed != null)
{
bool flag = reviewed[i][j][k];
ReviewParameters rps = (ReviewParameters)omr.Tag;
rps.ReviewRequired = flag;
VerificationParameters vp = rps.ErroredParameters;
vp.IsReviewed = !flag;
rps.ErroredParameters = vp;
}
}
}
}
}
}
return(reviewCounter);
}
// this prepares a recently deserialized workspace for use
internal void Unpack()
{
InitializeDefaults();
using (MemoryStream ms = new MemoryStream(filepathDictionaryBytes))
{
BinaryFormatter bf = new BinaryFormatter();
myImages = (Dictionary <string, string>)bf.Deserialize(ms);
ms.Close();
}
foreach (string key in myImages.Keys)
{
imageManager.Add(key, myImages[key]);
}
if (string.IsNullOrWhiteSpace(myAnswerkeyPath) == false)
{
imageManager.Add(IMGMGR_ANSWERS, myAnswerkeyPath);
}
template = MainForm.GetOmrEngine().CreateTemplateForm();
results = new List <IRecognitionForm>();
using (MemoryStream ms = new MemoryStream(templateBytes))
{
template.Load(ms);
}
templateImage = template.Pages[0].Image;
for (int i = 1; i < template.Pages.Count; i++)
{
templateImage.AddPage(template.Pages[i].Image);
}
if (answerBytes != null)
{
answers = MainForm.GetOmrEngine().CreateRecognitionForm();
using (MemoryStream ms = new MemoryStream(answerBytes))
{
answers.Load(ms);
}
answerReviewCounts = GetManualReviewCollection(answers, VerificationParameters.AllParameters);
}
resultReviewCounts = new ReviewCounter();
for (int i = 0; i < resultsBytes.Length; i++)
{
using (MemoryStream ms = new MemoryStream(resultsBytes[i]))
{
IRecognitionForm frm = MainForm.GetOmrEngine().CreateRecognitionForm();
frm.Load(ms);
resultReviewCounts += GetManualReviewCollection(frm, VerificationParameters.AllParameters, answers, reviewRequiredStatus[i]);
results.Add(frm);
}
}
}
// this prepares the workspace for serialization to disk
public void Pack(string filename)
{
this.locationOnDisk = filename;
filenames = new List <string>();
using (MemoryStream ms = new MemoryStream())
{
template.Save(ms);
templateBytes = ms.GetBuffer();
ms.Close();
}
if (answers != null)
{
using (MemoryStream ms = new MemoryStream())
{
answers.Save(ms);
answerBytes = ms.GetBuffer();
ms.Close();
}
}
using (MemoryStream ms = new MemoryStream())
{
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, myImages);
filepathDictionaryBytes = ms.GetBuffer();
ms.Close();
}
reviewRequiredStatus = new bool[results.Count][][][];
resultsBytes = new byte[results.Count][];
for (int i = 0; i < results.Count; i++)
{
IRecognitionForm frm = results[i];
reviewRequiredStatus[i] = new bool[frm.Pages.Count][][];
for (int j = 0; j < frm.Pages.Count; j++)
{
reviewRequiredStatus[i][j] = new bool[frm.Pages[j].Fields.Count][];
for (int k = 0; k < frm.Pages[j].Fields.Count; k++)
{
if (frm.Pages[j].Fields[k] is OmrField)
{
reviewRequiredStatus[i][j][k] = ((OmrField)frm.Pages[j].Fields[k]).Fields.ConvertAll <bool>(delegate(OmrCollection oc) { ReviewParameters rp = oc.Tag as ReviewParameters; return(rp != null ? rp.ReviewRequired : false); }).ToArray();
}
}
}
using (MemoryStream ms = new MemoryStream())
{
frm.Save(ms);
resultsBytes[i] = ms.GetBuffer();
ms.Close();
}
}
}
