public boolean generateIndex(
BufferedImage img, String filename, int frameno, Client client, FileWriter file) {
Initializer.initialize();
String color_name;
boolean isFace;
IplImage cvimage = IplImage.createFrom(img);
long[][] hsv_hist = new long[Initializer.NUM_BINS_HSV_HUE][Initializer.NUM_BINS_HSV_SAT];
color_name = Histogram.generateHistHSV(cvimage, hsv_hist);
if (color_name.equals("No")) return false;
isFace = faceDetection.faceDetect(cvimage);
long[] corner_hist = new long[Initializer.NUM_BINS_DIST_1D];
CornerDetector.findCorners(cvimage, corner_hist);
IplImage gray_img = null;
CvSize img_sz = null;
if (cvimage != null) img_sz = cvGetSize(cvimage);
if (img_sz != null) gray_img = cvCreateImage(img_sz, IPL_DEPTH_8U, 1);
else System.out.println("couldnt create image");
cvCvtColor(cvimage, gray_img, CV_BGR2GRAY);
long[][] apidq_hist =
new long[Initializer.NUM_BINS_DIST_APIDQ][Initializer.NUM_BINS_ANGLE_APIDQ];
Histogram.generateHistAPIDQ(gray_img, apidq_hist);
IplImage img_edge = cvCreateImage(cvGetSize(gray_img), gray_img.depth(), 1);
long[][] edge_hist = new long[Initializer.NUM_BINS_DIST_2D][Initializer.NUM_BINS_ANGLE_2D];
EdgeFinder.getegdes(gray_img, img_edge);
ContourFinder.findContour(img_edge, edge_hist);
// System.err.println(convertToString(corner_hist, apidq_hist, hsv_hist, edge_hist));
// System.err.println("------------");
String vector =
convertToString(color_name, isFace, corner_hist, apidq_hist, hsv_hist, edge_hist);
// insertIndexes(vector,filename,frameno, client);
client.admin().indices().refresh(new RefreshRequest("movie"));
IndexComparison incmp = new IndexComparison();
if (incmp.compare_reject(filename, frameno, vector, client) != -1) {
insertIndexes(vector, filename, frameno, client);
client.admin().indices().refresh(new RefreshRequest("movie"));
// System.err.println(filename+"_"+frameno+" ** inserted");
return true;
}
// else System.err.println(filename+"_"+frameno+"-------not inserted");
client.admin().indices().refresh(new RefreshRequest("movie"));
return false;
// insertIndexes(vector,filename,frameno, client);
// WARNING NOT RELEASED-------------------------------------------------------
// gray_img..release(); //cvReleaseImage(gray_img);//if(!gray_img.isNull())gray_img.release();
// img_edge.release(); //cvReleaseImage(img_edge);//if(!img_edge.isNull())img_edge.release();
// cvimage.release(); //cvReleaseImage(cvimage);//cvimage.release();
}
public IplImage DetectFaces(IplImage image) throws Exception {
// Converts the image to gray scale for detection to work, using the same dimensions as the
// original.
IplImage grayImage = IplImage.createFrom(convertColorToGray(image.getBufferedImage()));
CvMemStorage storage = CvMemStorage.create();
// Using the cascade file, this creates a classification for what objects to detect. In our case
// it is the anterior of the face.
CvHaarClassifierCascade classifier = new CvHaarClassifierCascade(cvLoad(CASCADE_FILE));
// Detect Haar-like objects, depending on the classifier. In this case we use a classifier for
// detecting the anterior of the face.
CvSeq faces = cvHaarDetectObjects(grayImage, classifier, storage, 1.1, 1, 0);
// Initialize the static variables in FaceScanner for determining the area to crop the largest
// detected face.
FaceScanner.height = 0;
FaceScanner.width = 0;
FaceScanner.x = 0;
FaceScanner.y = 0;
// Loop through all detected faces and save the largest (closest) face.
for (int i = 0; i < faces.total(); i++) {
CvRect rect = new CvRect(cvGetSeqElem(faces, i));
if (FaceScanner.width < rect.width()) {
FaceScanner.width = rect.width();
FaceScanner.height = rect.height();
FaceScanner.x = rect.x();
FaceScanner.y = rect.y();
}
if (FaceScanner.displayRects) {
/*Uncomment to draw the rectangles around the detected faces.*/
// if(rect.width() > 130 && rect.height() > 130){
// Draw a square around the detected face.
cvRectangle(
image,
cvPoint(rect.x(), rect.y()),
cvPoint(rect.x() + rect.width(), rect.y() + rect.height()),
CvScalar.GREEN,
2,
CV_AA,
0);
// }
/*-----------------------------------------------------------*/
}
}
// Checks that there was a detected face in the image before saving. Also, the detected "face"
// must be large enough to be considered
// a detected face. This is to limit the amount of erroneous detections. This saves the full
// size image with detections drawn on
// whole image before cropping.
if (!(FaceScanner.height == 0 && FaceScanner.width == 0)
&& !(FaceScanner.height < 130 && FaceScanner.width < 130)) {
// Save the image with rectangles.
// cvSaveImage(filename.replace(".png", "-Rect.png"), image);
} else {
return null;
}
return image;
}
public static void main(String[] args)
throws IOException, InterruptedException, IM4JavaException,
PdfException { // is - is the inputstream of the pdf file
System.out.println("inside grader");
// required debugging code
Mongo m = new Mongo();
DB db = m.getDB("ecomm_database");
DBCollection coll = db.getCollection("testschemas");
ObjectMapper mapper = new ObjectMapper();
// String message = "4fda1af52f910cc6200000d3"; //test id, that i will have in the real version
String message = "500bb8811a316fda2400003b"; // id of second test
DBObject TestObject =
coll.findOne(new BasicDBObject("_id", new ObjectId(message))); // the actual mongo query
System.out.println("Test Object = " + TestObject);
JsonNode rootNode = mapper.readValue(TestObject.toString().getBytes("UTF-8"), JsonNode.class);
JsonNode TestAnswerSheet = rootNode.get("TestAnswerSheet"); // TestAnswerSheet
JsonNode Questions = rootNode.get("Questions");
System.out.println("size of Questions = " + Questions.size());
int numofquestions = Questions.size();
System.out.println("size of answers = " + TestAnswerSheet.size());
int numofstudents =
rootNode.get("NumberOfStudents").getIntValue(); // grab the number of students
System.out.println("Numer of students = " + numofstudents);
// FillScore(Questions);
// for(int x = 0; x < Answers.size(); x++){
//
// int IDS = Answers.get(x).get("IDS").getIntValue(); //grab the question
// String QID = new String(Answers.get(x).get("IDS").getTextValue()); //grab the question
// System.out.println("IDS = " + QID );
//
// }//end of grade results
// JFrame frame = new JFrame(); //window popup //for debuggin
// reading in file
// File PDF_file = new File("/Users/angellopozo/Documents/TestImages/PDF_CRICLEV2.pdf");
/*
*
* Start of real code
*
*/
// //workign with jpedal, will read from inputstream
// PdfDecoder decode_pdf = new PdfDecoder(true);
// try{
//// decode_pdf.openPdfFileFromInputStream(is,true); //file
// decode_pdf.openPdfFile("/Users/angellopozo/Dropbox/My
// Code/java/MainRabbitMongo/Resources/CreatedPDF_Mongo_Test.pdf"); ///DEUG LINE
//// BufferedImage img = decode_pdf.getPageAsImage(1);
//// decode_pdf.closePdfFile();
//// File fileToSave = new File("/Users/angellopozo/Dropbox/My
// Code/java/MainRabbitMongo/src/main/java/RPC/jpedalRPCTEST1.jpg");
//// ImageIO.write(img, "jpg", fileToSave);
//// JFrame frame = new JFrame("jpedal buffered image");
//// Panel panel = new Panel();
//// frame.getContentPane().add(new JLabel(new ImageIcon(img)));
//// frame.pack();
////// frame.setLocationRelativeTo(null);
//// frame.setVisible(true);
// PdfFileInformation fileinfo = decode_pdf.getFileInformationData();
// String[] Fnames = fileinfo.getFieldValues();
// for(int i = 0 ; i < Fnames.length; i++){
// System.out.println("fname info = " + Fnames[i]);
// }
// System.out.println("xml data = " + fileinfo.getFileXMLMetaData());
// System.out.println("name of the input stream file = " + decode_pdf.getFileName());
// }
// catch(PdfException e) {
// e.printStackTrace();//return back and do the rpc to the user ... use return and check
// returns?
//
// }
// File PDF_file = new File("/Users/angellopozo/Dropbox/My
// Code/java/MainRabbitMongo/Resources/CreatedPDF_TestMongo_Graded.pdf"); //to large, need to do
// some scaling
// File PDF_file = new File("/Users/angellopozo/Dropbox/My
// Code/java/MainRabbitMongo/Resources/CreatedPDF_Mongo_Test_Inputs.pdf"); //working
// File PDF_file = new File("/Users/angellopozo/Dropbox/My
// Code/java/MainRabbitMongo/Resources/CreatedPDF_Mongo_Grade_Random.pdf");
// File PDF_file = new File("/Users/angellopozo/Dropbox/My
// Code/java/MainRabbitMongo/Resources/CreatedPDF_TestMongo_Graded_Vsmaller.pdf");
File PDF_file =
new File(
"/Users/angellopozo/Dropbox/My Code/java/MainRabbitMongo/Resources/CreatedPDF_Mongo_Random_withScore_testnum2_Grade_LARGE.pdf");
// File PDF_file = new File("/Users/angellopozo/Dropbox/My
// Code/java/MainRabbitMongo/Resources/CreatedPDF_Mongo_Random_withScore_testnum2_Grade_LARGE_MISTAKES_doubles.pdf");
// File PDF_file = new File("/Users/angellopozo/Dropbox/My
// Code/java/MainRabbitMongo/Resources/CreatedPDF_Mongo_Random_withScore_testnum2_Grade_LARGE_MISTAKES_noreply.pdf");
// just testing. I get a bufferedImageLuminanceSource.java.39 -> grabbing image file dimentions.
// PdfDecoder decode_pdf = new PdfDecoder(true);
// decode_pdf.openPdfFile("/Users/angellopozo/Dropbox/My
// Code/java/MainRabbitMongo/Resources/CreatedPDF_Mongo_Grade_Random.pdf");
// int numpages = decode_pdf.getPageCount();
PDDocument doc = PDDocument.load(PDF_file); // used to get page numbers
int numpages = doc.getNumberOfPages(); // get page numbers for for loop
int[] CorrectlyAnswered = new int[Questions.size()]; // number of correct answers
int[] IncorrectlyAnswered =
new int[Questions.size()]; // number of incorrectly answered responses
byStudent bystudent =
new byStudent(
numofquestions,
numofstudents); // create grading instance //Initialize with number of students
byQuestion byquestion = new byQuestion(numofquestions, numofstudents);
System.out.println("result size = " + CorrectlyAnswered.length);
// need to fill the score array in byquestions
for (int i = 0; i < Questions.size(); i++) {
// System.out.println("Score for this question = " +
// Questions.get(i).get("Score").getDoubleValue());
byquestion.ScoreDefault[i] = Questions.get(i).get("Score").getDoubleValue();
} // end of filling score array in byquestion
// int numpages = decode_pdf.getPageCount(); //get page numbers for for loop
System.out.println(
"number of pages = "
+ numpages); // check to make sure the number of pages is reasonable, dont want this to
// be too large call Db and return
System.out.println("____________________________________");
// JFrame frame = new JFrame(); //window popup
// ArrayList Results = new ArrayList(); //Array of the answer locations
// ArrayList WA = new ArrayList(); //array of wrong answers that were selected by the students
// ArrayList SR = new ArrayList(); //holding accumulated data below. selected answers array
int numoffails = 0;
int Aindex = 0;
// int Qindex = 0;
int[][] Selections = new int[2][Questions.size()]; // student , question
int[][] SelectionTotal = new int[Questions.size()][4]; // question, answer selected
for (int i = 0; i < numpages; i++) { // for every page
// File PDF_file = new File("/Users/angellopozo/Documents/TestImages/PDF_CRICLEV2.pdf");
// convert page to PDF
BufferedImage PDF_img = ConvertPageToImage(PDF_file, i);
// BufferedImage PDF_img = decode_pdf.getPageAsImage(i);
// START creating luminance source
LuminanceSource lumSource = new BufferedImageLuminanceSource(PDF_img);
BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(lumSource));
Reader reader = new QRCodeReader(); // create qr reader
GenericMultipleBarcodeReader multireader = new GenericMultipleBarcodeReader(reader);
Hashtable<DecodeHintType, Object> hints = new Hashtable<DecodeHintType, Object>();
hints.put(DecodeHintType.TRY_HARDER, Boolean.TRUE);
TreeMap<String, Rectangle2D> sortedBarcodeResults = new TreeMap<String, Rectangle2D>();
Result results[] = null;
try {
results = multireader.decodeMultiple(bitmap, hints);
} catch (ReaderException re) {
return;
} // end of try
// END creating luminance source
// go through each found QR Code and draw a box around it
BufferedImage outimage = PDF_img; // copy of the pdf image
Graphics2D g2 = outimage.createGraphics();
g2.setColor(Color.green);
g2.setStroke(new BasicStroke(3));
// draw boxes around the found qrcodes
int index = 0; // debug line to save images
for (Result result : results) {
System.out.println("barcode result: " + result.getText());
double x1 = result.getResultPoints()[0].getX(); // top left
double y1 = result.getResultPoints()[0].getY(); // top left
double x2 = result.getResultPoints()[1].getX(); // top right
double y2 = result.getResultPoints()[1].getY(); // top right
double x3 = result.getResultPoints()[2].getX(); // bottom left
double y3 = result.getResultPoints()[2].getY(); // bottom left
// double x4 = result.getResultPoints()[3].getX(); //bottom right (bottom right square
// location..some qr have it)
// double y4 = result.getResultPoints()[3].getY(); //bottom right (bottom right square
// location..some qr have it)
Rectangle2D rectbox = new Rectangle2D.Double(x2, y2, (x3 - x2), (y1 - y2));
// Double buffer = 10.0;//highly dependent on the size of the qrcode
// Rectangle2D rectbox = new Rectangle2D.Double(x2-buffer, y2-buffer, (x3-x2)+2*buffer,
// (y1-y2)+2*buffer);
// System.out.println("barcode location: " + x1 +" "+ y1 +" "+ x2 +" "+ y2 + " " +
// x3 +" "+ y3);
// System.out.println("barcode location: " + x3 +" "+ y3+" "+ x4+" "+ y4+"\n");// +" "+
// (x2-x1) +" "+ (y2-y1) +"\n");
sortedBarcodeResults.put(
result.getText(), rectbox); // (qrdecoded string , rectangle box in pixels)
g2.draw(rectbox); // draw box around qrcode
Rectangle2D bubblebox =
new Rectangle2D.Double(
x2 + (x3 - x2) + 15, y2 - 20, 45, (y1 - y2) + 55); // box around bubbles
g2.draw(bubblebox); // area that the bubbles exist in the image
BufferedImage subBubble =
PDF_img.getSubimage(
(int) (x2 + (x3 - x2) + 15),
(int) (y2 - 20),
45,
(int) ((y1 - y2) + 55)); // box around bubbles
IplImage ipl_subBubble = IplImage.createFrom(subBubble); // convert subimage into iplimage
IplImage ipl_subBubble_large =
cvCreateImage(
cvSize(ipl_subBubble.width() * 4, ipl_subBubble.height() * 4),
ipl_subBubble.depth(),
ipl_subBubble.nChannels());
cvResize(ipl_subBubble, ipl_subBubble_large, CV_INTER_CUBIC); // enlarge image
IplImage ipl_subBubble_gray =
cvCreateImage(
cvSize(ipl_subBubble_large.width(), ipl_subBubble_large.height()),
IPL_DEPTH_8U,
1); // create black and white version of page
// IplImage ipl_subBubble_gray = ipl_subBubble_large.clone();
if (ipl_subBubble_large.nChannels() > 1) {
cvCvtColor(ipl_subBubble_large, ipl_subBubble_gray, CV_RGB2GRAY);
} else {
// IplImage ipl_subBubble_gray = ipl_subBubble_large.clone();
}
cvThreshold(ipl_subBubble_gray, ipl_subBubble_gray, 100, 255, CV_THRESH_OTSU);
cvSmooth(ipl_subBubble_gray, ipl_subBubble_gray, CV_GAUSSIAN, 9, 9, 2, 2);
CvMemStorage circles = CvMemStorage.create();
// show bubbles, check this if no grading is working
// CanvasFrame smoothed = new CanvasFrame("gray image");
// smoothed.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);
// smoothed.showImage(ipl_subBubble_gray);
CvSeq seq =
cvHoughCircles(
ipl_subBubble_gray,
circles,
CV_HOUGH_GRADIENT,
1,
50,
80,
20,
32,
(int) (ipl_subBubble_gray.height() / (7)));
Integer[][] FilledBubbles =
new Integer[4][4]; // arry holds the #of pixels seen and the y dimention of subimage
// Vector<CvPoint> centers = new Vector<CvPoint>(4);//the 4 can be seq.total()
for (int j = 0; j < seq.total(); j++) { // draw a circle around each circle found
CvPoint3D32f xyr = new CvPoint3D32f(cvGetSeqElem(seq, j));
CvPoint center = new CvPoint(Math.round(xyr.x()), Math.round(xyr.y()));
int radius = Math.round(xyr.z());
cvCircle(ipl_subBubble_large, center, 3, CvScalar.GREEN, -1, 8, 0); // center of circle
cvCircle(ipl_subBubble_large, center, radius, CvScalar.BLUE, 3, 8, 0); // outer circle
FilledBubbles[j][0] =
FindBubbleSelected(center, radius, ipl_subBubble_gray); // bubble selected area
// FilledBubbles[j][0] = 1; //here to get rid of dimensions error
FilledBubbles[j][1] = Math.round(center.x());
FilledBubbles[j][2] = Math.round(center.y());
FilledBubbles[j][3] = Math.round(radius);
// System.out.println("Filled bubble Count = "+ FilledBubbles[j]);
} // end of look for circles for
// //the algorithm may not find circles //was trying to fix an old error, solved it by
// fixing th size of the image on hte pdf to image conversion
// int anynull = anynulls(FilledBubbles);
//// System.out.println("anynull = "+ anynull);
// if(anynull == 1){
// numoffails++;
// continue; //this question, not all circles were found.
// }//end of null check //this means not all 4 circles were found
// System.out.println("filled bubbles size = " + FilledBubbles[0].length);
// System.out.println("filled bubbles size = " + FilledBubbles.length);
FilledBubbles =
SortbyYdimention(
FilledBubbles); // note to self, check for nulls because that woud be an issue....
// print out area of bubble
// for(Integer[] tp : FilledBubbles){
// System.out.println("Filled bubble Count = "+ tp[0] + " loc = "+ tp[1]);
// }
int[] selectResult =
ReturnIndexOfmax(FilledBubbles); // maxindex = the answer submitted by the student
int maxIndex = selectResult[0];
int isfound = 1;
int ismulti = 0;
if (selectResult[1] > 1
|| selectResult[2]
== 1) { // selectResult[1] = number of bubbles , selectResult[2] = no selections
// made
System.out.println("more than one bubble was selected");
// Aindex++; //index for looping through answer array //need to be
// incremented to keep data correct
// index++; //(0-number of questions) //need to be incremented to keep data
// correct
// numoffails++; //student selected too many inputs, hence trying to cheat
// and
isfound = 0;
ismulti = 1;
// continue;
} // end of slectResults[1] if
/* GRADE THE RESULTS!!! */
// TestObject =mongo query result, Aindex = question being looked at
String QID =
new String(
TestAnswerSheet.get(Aindex).get("IDS").getTextValue()); // grab the question ID
int CorrectAnswerloc =
TestAnswerSheet.get(Aindex).get("Answer").getIntValue(); // correct answer location
System.out.println("Correc answer location = " + CorrectAnswerloc);
System.out.println("IDS = " + QID + " QI = " + Aindex);
int iscorrect = 0;
if (ismulti == 1) { // if multiple selected
iscorrect = 0;
} else { // if only one input for a question is found
iscorrect = checkcorrectness(CorrectAnswerloc, maxIndex);
}
// create the student selections by question found
BasicDBObject newvals = new BasicDBObject();
String Answersnum = new String("TestAnswerSheet." + Integer.toString(Aindex));
newvals.put(Answersnum + ".found", isfound);
newvals.put(Answersnum + ".multiselect", ismulti);
// newvals.put(Answersnum + ".correct", iscorrect);
// newvals.put(Answersnum + ".selected", maxIndex);
BasicDBObject posop = new BasicDBObject("$set", newvals);
System.out.println("inc query = " + posop.toString());
coll.update(new BasicDBObject("_id", new ObjectId(message)), posop);
// System.out.println("first character = " + QID.charAt(0));
// System.out.println("last character = " + QID.charAt(2));
char stud =
QID.charAt(0); // this is the student //QID starts at 1, not at 0 hence the negative
char Q = QID.charAt(2); // this is the question
System.out.println("Student num = " + stud);
System.out.println(
"Q num = "
+ Character.getNumericValue(Q - 1)); // QID starts at 1, not at 0 hence the negative
// Aggregate information to create Test Results array
int Qint =
Aindex
% numofquestions; // Qint = the question number of the test -1(includes 0 hence the
// -1) //should be equivalent to char Q
// System.out.println("Score for this question = " +
// Questions.get(Qint).get("Score").getDoubleValue());
if (iscorrect == 1) {
System.out.println("mod result = " + Qint);
System.out.println("Question = " + Qint + " is correct = " + iscorrect);
CorrectlyAnswered[Qint] =
CorrectlyAnswered[Qint] + 1; // byquestion.IncrementCorrectlyAnswered(Qint);
byquestion.IncrementCorrectlyAnswered(Qint);
bystudent.IncrementCorrectlyAnswered(Character.getNumericValue(stud));
byquestion.InsertScore(Character.getNumericValue(stud), Qint);
} else if (iscorrect
== 0) { // wrong answer was selected // Selections // or multiple selections
System.out.println("mod result = " + Qint);
System.out.println("Question = " + Qint + " is Incorrect = " + iscorrect);
IncorrectlyAnswered[Qint] =
IncorrectlyAnswered[Qint] + 1; // byquestion.IncrementCorrectlyAnswered(Qint);
byquestion.IncrementIncorrectlyAnswered(Qint);
bystudent.IncrementIncorrectlyAnswered(Character.getNumericValue(stud));
}
byquestion.IncrementSelectedAnswer(
maxIndex, Qint); // increment the number of times a selection was made
Selections[Character.getNumericValue(stud)][Qint] = maxIndex;
SelectionTotal[Qint][maxIndex] =
SelectionTotal[Qint][maxIndex]
+ 1; // byquestion.IncrementSelectedWrongAnwer(Qint, maxIndex);
bystudent.IncrementRepliedTo(Character.getNumericValue(stud));
Aindex++; // index for looping through answer array
/* END GRADE THE RESULTS!!! */
// TestObject
// draw the red circles
CvPoint slectedcenter =
new CvPoint(
FilledBubbles[maxIndex][1].intValue(), FilledBubbles[maxIndex][2].intValue());
cvCircle(
ipl_subBubble_large,
slectedcenter,
FilledBubbles[maxIndex][3].intValue(),
CvScalar.RED,
3,
8,
0);
// saving subimages to i can debug results
// String subimagename = new String("subimage_"+i+"_"+index+".jpg");
index++; // (0-number of questions)
// cvSaveImage(subimagename,ipl_subBubble_large);
// create image window named "My Image"
// String que = new String("_for_"+ result.getText());
// final CanvasFrame canvas = new CanvasFrame("Bubbles_Found"+que);
// // request closing of the application when the image window is closed
// canvas.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);
// // show image on window
// canvas.showImage(ipl_subBubble_large);
System.out.println("____________________________________");
} // end of for results loop
// end drawing boxes around each QR CODE
// //START code to display in JFRAME
// if(i == 0){
// frame.getContentPane().setLayout(new FlowLayout());
// frame.getContentPane().add(new JLabel(new ImageIcon(outimage)));
// frame.pack();
// frame.setVisible(true);
// }
// else {
//
// frame.getContentPane().add(new JLabel(new ImageIcon(outimage)));
// frame.pack();
// frame.setVisible(true);
//
// }
// //END code to display in JFRAME
} // end of for loop of pages
// putput how well teh students performed on test
for (int i = 0; i < numofstudents; i++) {
System.out.println(
"student" + i + "answered Correctly: " + bystudent.CorrectlyAnswered[i] + " Questions");
System.out.println(
"student"
+ i
+ "answered Incorrectly: "
+ bystudent.IncorrectlyAnswered[i]
+ " Questions");
System.out.println("student" + i + "answered: " + bystudent.RepliedTo[i] + " Questions");
}
// results by student and question
for (int i = 0; i < Selections.length; i++) {
for (int j = 0; j < Selections[0].length; j++) {
System.out.println("Student (" + i + "," + j + ") selected = " + Selections[i][j]);
}
}
// results by question and reply
for (int i = 0; i < SelectionTotal.length; i++) {
System.out.println(
"Selection below = "
+ byquestion.SelectedWrongAnswer_0[i]
+ " "
+ byquestion.SelectedWrongAnswer_1[i]
+ " "
+ byquestion.SelectedWrongAnswer_2[i]
+ " "
+ byquestion.SelectedCorrectAnswer[i]
+ " ");
System.out.println(
"correctly answered = " + byquestion.CorrectlyAnswered[i] + " " + CorrectlyAnswered[i]);
for (int j = 0; j < SelectionTotal[0].length; j++) {
System.out.println("Quesetion (" + i + "," + j + ") selected = " + SelectionTotal[i][j]);
}
} // end of selctiontotal for loop
byquestion.ComputePercentCorrectlyAnswered();
byquestion.ComputePercentIncorrectlyAnswered();
byquestion.ComputePercentCorrectSTD();
byquestion.ComputeMeanScoreByQuestion(); // average score for any question by question
// byquestion.ComputeMeanScoreByStudent(); //average score for any one question by student
byquestion.ComputeMeanbyQuestionSTD();
bystudent.ComputeTotalScores(
byquestion.Scoresbystudent); // compute the total scores for any student
bystudent.ComputeMeanTotalScore(byquestion.Scoresbystudent);
byTest bytest = new byTest(numofquestions, numofstudents, bystudent);
bytest.ComputeMeanScoreTest();
bytest.ComputeMeanScoreSTD();
bytest.ComputePercentCorrecltyAnswered();
bytest.ComputePercentIncorrecltyAnswered();
// create Test Results by question
ArrayList<BasicDBObject> TestResultbyQuestion =
new ArrayList<BasicDBObject>(); // Array of the answer locations
for (int j = 0; j < byquestion.CorrectlyAnswered.length; j++) {
BasicDBObject ByQuestionVals = new BasicDBObject();
ByQuestionVals.put("SelectedWrongAnswer_0", byquestion.SelectedWrongAnswer_0[j]);
ByQuestionVals.put("SelectedWrongAnswer_1", byquestion.SelectedWrongAnswer_1[j]);
ByQuestionVals.put("SelectedWrongAnswer_2", byquestion.SelectedWrongAnswer_2[j]);
ByQuestionVals.put("SelectedCorrectAnswer", byquestion.SelectedCorrectAnswer[j]);
ByQuestionVals.put("CorrectlyAnswered", byquestion.CorrectlyAnswered[j]);
ByQuestionVals.put("IncorrectlyAnswered", byquestion.IncorrectlyAnswered[j]);
ByQuestionVals.put("PercentCorrect", byquestion.PercentCorrectlyAnswered[j]);
ByQuestionVals.put("PercentIncorrect", byquestion.PercentIncorrectlyAnswered[j]);
ByQuestionVals.put("STD", byquestion.STD[j]);
ByQuestionVals.put("Mean", byquestion.ScoreMean[j]); // means score for this question
ByQuestionVals.put("_id", new ObjectId());
TestResultbyQuestion.add(ByQuestionVals); // add Rvals into the Testresultarray listarray
// System.out.println("Question " + j + " numcorrect = " + CorrectlyAnswered[j]);
}
// create Test Results by test
BasicDBObject ByTestVals = new BasicDBObject();
ByTestVals.put("Mean", bytest.ScoreMean);
ByTestVals.put("STD", bytest.ScoreSTD);
ByTestVals.put("PercentCorrect", bytest.PercentCorrectlyAnswered);
ByTestVals.put("PercentInorrect", bytest.PercentIncorrectlyAnswered);
ByTestVals.put("_id", new ObjectId());
// create graded exists
BasicDBObject TestGradedVals = new BasicDBObject();
TestGradedVals.put("WasGraded", 1);
Date now = new Date();
TestGradedVals.put("GradeOn", now);
TestGradedVals.put("_id", new ObjectId());
// create Test Results by student
ArrayList<BasicDBObject> TestResultbyStudent =
new ArrayList<BasicDBObject>(); // Array of the answers by student
for (int j = 0; j < bystudent.CorrectlyAnswered.length; j++) {
BasicDBObject ByStudentVals = new BasicDBObject();
ByStudentVals.put("CorrectlyAnswered", bystudent.CorrectlyAnswered[j]);
ByStudentVals.put("IncorrectlyAnswered", bystudent.IncorrectlyAnswered[j]);
ByStudentVals.put("RepliedTo", bystudent.RepliedTo[j]);
ByStudentVals.put("ScoreTotal", bystudent.ScoreTotal[j]);
// ByStudentVals.put("ScoreMean", bystudent.ScoreMean[j]); //this is still wrong, unless i
// want ot show the mean of score for any 1 question
ByStudentVals.put("_id", new ObjectId());
TestResultbyStudent.add(ByStudentVals); // add Rvals into the Testresultarray listarray
// System.out.println("Question " + j + " numcorrect = " + CorrectlyAnswered[j]);
}
// v1
BasicDBObject TRbyQuestions = new BasicDBObject("TRbyQuestions", TestResultbyQuestion);
BasicDBObject set = new BasicDBObject("$set", TRbyQuestions);
// System.out.println("Test result query = " + TRbyQuestions);
coll.update(new BasicDBObject("_id", new ObjectId(message)), set);
BasicDBObject TRbyTest = new BasicDBObject("TRbyTest", ByTestVals);
BasicDBObject settest = new BasicDBObject("$set", TRbyTest);
coll.update(new BasicDBObject("_id", new ObjectId(message)), settest);
BasicDBObject TestGradedobject = new BasicDBObject("TestGraded", TestGradedVals);
BasicDBObject settestgraded = new BasicDBObject("$set", TestGradedobject);
coll.update(new BasicDBObject("_id", new ObjectId(message)), settestgraded);
BasicDBObject TRbyStudent = new BasicDBObject("TRbyStudents", TestResultbyStudent);
BasicDBObject set1 = new BasicDBObject("$set", TRbyStudent);
coll.update(new BasicDBObject("_id", new ObjectId(message)), set1);
// v2
// DBObject TestObject2 = coll.findOne(new BasicDBObject("_id", new ObjectId(message))); //the
// actual mongo query
// TestObject2.put("CorrectlyAnswered", TestResultsarray);
// coll.save(TestObject2);
System.out.println("Failed to grade " + numoffails + " questions");
doc.close();
} // end of Grader
public static BufferedImage paint(BufferedImage input, Block node) {
IplImage canvas = IplImage.createFrom(input);
paint(canvas, node);
return canvas.getBufferedImage();
}