Пример #1
0
  /**
   * Receives frame and uses face recognition algorithms to set coordinates of faces
   *
   * @param originalImage
   * @return list of integer arrays, with coordinates and size of faces
   */
  public static List<Integer[]> detect(IplImage originalImage) {

    List<Integer[]> facesList = new ArrayList<Integer[]>();

    IplImage grayImage =
        IplImage.create(originalImage.width(), originalImage.height(), IPL_DEPTH_8U, 1);

    cvCvtColor(originalImage, grayImage, CV_BGR2GRAY);

    CvMemStorage storage = CvMemStorage.create();
    opencv_objdetect.CvHaarClassifierCascade cascade =
        new opencv_objdetect.CvHaarClassifierCascade(cvLoad(CASCADE_FILE));

    CvSeq faces = cvHaarDetectObjects(grayImage, cascade, storage, 1.1, 1, 0);

    Integer[] coordinates = null;
    for (int i = 0; i < faces.total(); i++) {
      CvRect r = new CvRect(cvGetSeqElem(faces, i));
      coordinates = new Integer[4];
      coordinates[0] = r.x();
      coordinates[1] = r.y();
      coordinates[2] = r.height();
      coordinates[3] = r.width();
      facesList.add(coordinates);
    }
    return facesList;
  }
  public static void detect(IplImage src) {

    CvHaarClassifierCascade cascade = new CvHaarClassifierCascade(cvLoad(XML_FILE));
    CvMemStorage storage = CvMemStorage.create();
    CvSeq sign = cvHaarDetectObjects(src, cascade, storage, 1.5, 3, CV_HAAR_DO_CANNY_PRUNING);

    cvClearMemStorage(storage);

    int total_Faces = sign.total();

    for (int i = 0; i < total_Faces; i++) {
      CvRect r = new CvRect(cvGetSeqElem(sign, i));
      cvRectangle(
          src,
          cvPoint(r.x(), r.y()),
          cvPoint(r.width() + r.x(), r.height() + r.y()),
          CvScalar.RED,
          2,
          CV_AA,
          0);
    }

    cvShowImage("Result", src);
    cvSaveImage("D:\\asd\\a.jpg", src);
    cvWaitKey(0);
  }
Пример #3
0
  public void generatePGMFromPic(String srcPath, String file, String destPath) throws Exception {

    String srcFilePath = srcPath + "/" + file;
    System.out.println("Loading image from " + srcFilePath);
    IplImage origImg = cvLoadImage(srcFilePath);

    // convert to grayscale
    IplImage grayImg = IplImage.create(origImg.width(), origImg.height(), IPL_DEPTH_8U, 1);
    cvCvtColor(origImg, grayImg, CV_BGR2GRAY);

    // scale the grayscale (to speed up face detection)
    IplImage smallImg =
        IplImage.create(grayImg.width() / SCALE, grayImg.height() / SCALE, IPL_DEPTH_8U, 1);
    cvResize(grayImg, smallImg, CV_INTER_LINEAR);

    // equalize the small grayscale
    IplImage equImg = IplImage.create(smallImg.width(), smallImg.height(), IPL_DEPTH_8U, 1);
    cvEqualizeHist(smallImg, equImg);

    CvMemStorage storage = CvMemStorage.create();

    CvHaarClassifierCascade cascade = new CvHaarClassifierCascade(cvLoad(CASCADE_FILE));
    System.out.println("Detecting faces...");
    CvSeq faces = cvHaarDetectObjects(equImg, cascade, storage, 1.1, 3, CV_HAAR_DO_CANNY_PRUNING);
    cvClearMemStorage(storage);
    int total = faces.total();
    System.out.println("Found " + total + " face(s)");
    for (int i = 0; i < total; i++) {
      CvRect r = new CvRect(cvGetSeqElem(faces, i));
      cvSetImageROI(
          origImg, cvRect(r.x() * SCALE, r.y() * SCALE, r.width() * SCALE, r.height() * SCALE));
      IplImage origface = cvCreateImage(cvSize(r.width() * SCALE, r.height() * SCALE), 8, 3);

      IplImage smallface = cvCreateImage(cvSize(120, 120), 8, 3);
      cvCopy(origImg, origface);
      cvResize(origface, smallface, CV_INTER_LINEAR);
      cvSaveImage(destPath + "/" + file + i + ".pgm", smallface);
      cvResetImageROI(origImg);
    }
  }
  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
Пример #5
0
  /** usage: java HoughLines imageDir\imageName TransformType */
  public static void main(String[] args) {

    String fileName =
        args.length >= 1 ? args[0] : "pic1.png"; // if no params provided, compute the defaut image
    IplImage src = cvLoadImage(fileName, 0);
    IplImage dst;
    IplImage colorDst;
    CvMemStorage storage = cvCreateMemStorage(0);
    CvSeq lines = new CvSeq();

    CanvasFrame source = new CanvasFrame("Source");
    CanvasFrame hough = new CanvasFrame("Hough");
    if (src == null) {
      System.out.println("Couldn't load source image.");
      return;
    }

    dst = cvCreateImage(cvGetSize(src), src.depth(), 1);
    colorDst = cvCreateImage(cvGetSize(src), src.depth(), 3);

    cvCanny(src, dst, 50, 200, 3);
    cvCvtColor(dst, colorDst, CV_GRAY2BGR);

    /*
     * apply the probabilistic hough transform
     * which returns for each line deteced two points ((x1, y1); (x2,y2))
     * defining the detected segment
     */
    if (args.length == 2 && args[1].contentEquals("probabilistic")) {
      System.out.println("Using the Probabilistic Hough Transform");
      lines = cvHoughLines2(dst, storage, CV_HOUGH_PROBABILISTIC, 1, Math.PI / 180, 40, 50, 10);
      for (int i = 0; i <= lines.total(); i++) {
        // from JavaCPP, the equivalent of the C code:
        // CvPoint* line = (CvPoint*)cvGetSeqElem(lines,i);
        // CvPoint first=line[0], second=line[1]
        // is:
        // CvPoint first=line.position(0), secon=line.position(1);

        Pointer line = cvGetSeqElem(lines, i);
        CvPoint pt1 = new CvPoint(line).position(0);
        CvPoint pt2 = new CvPoint(line).position(1);

        System.out.println("Line spotted: ");
        System.out.println("\t pt1: " + pt1);
        System.out.println("\t pt2: " + pt2);
        cvLine(colorDst, pt1, pt2, CV_RGB(255, 0, 0), 3, CV_AA, 0); // draw the segment on the image
      }
    }
    /*
     * Apply the multiscale hough transform which returns for each line two float parameters (rho, theta)
     * rho: distance from the origin of the image to the line
     * theta: angle between the x-axis and the normal line of the detected line
     */
    else if (args.length == 2 && args[1].contentEquals("multiscale")) {
      System.out.println("Using the multiscale Hough Transform"); //
      lines = cvHoughLines2(dst, storage, CV_HOUGH_MULTI_SCALE, 1, Math.PI / 180, 40, 1, 1);
      for (int i = 0; i < lines.total(); i++) {
        CvPoint2D32f point = new CvPoint2D32f(cvGetSeqElem(lines, i));

        float rho = point.x();
        float theta = point.y();

        double a = Math.cos((double) theta), b = Math.sin((double) theta);
        double x0 = a * rho, y0 = b * rho;
        CvPoint
            pt1 =
                new CvPoint((int) Math.round(x0 + 1000 * (-b)), (int) Math.round(y0 + 1000 * (a))),
            pt2 =
                new CvPoint((int) Math.round(x0 - 1000 * (-b)), (int) Math.round(y0 - 1000 * (a)));
        System.out.println("Line spoted: ");
        System.out.println("\t rho= " + rho);
        System.out.println("\t theta= " + theta);
        cvLine(colorDst, pt1, pt2, CV_RGB(255, 0, 0), 3, CV_AA, 0);
      }
    }
    /*
     * Default: apply the standard hough transform. Outputs: same as the multiscale output.
     */
    else {
      System.out.println("Using the Standard Hough Transform");
      lines = cvHoughLines2(dst, storage, CV_HOUGH_STANDARD, 1, Math.PI / 180, 90, 0, 0);
      for (int i = 0; i < lines.total(); i++) {
        CvPoint2D32f point = new CvPoint2D32f(cvGetSeqElem(lines, i));

        float rho = point.x();
        float theta = point.y();

        double a = Math.cos((double) theta), b = Math.sin((double) theta);
        double x0 = a * rho, y0 = b * rho;
        CvPoint
            pt1 =
                new CvPoint((int) Math.round(x0 + 1000 * (-b)), (int) Math.round(y0 + 1000 * (a))),
            pt2 =
                new CvPoint((int) Math.round(x0 - 1000 * (-b)), (int) Math.round(y0 - 1000 * (a)));
        System.out.println("Line spotted: ");
        System.out.println("\t rho= " + rho);
        System.out.println("\t theta= " + theta);
        cvLine(colorDst, pt1, pt2, CV_RGB(255, 0, 0), 3, CV_AA, 0);
      }
    }
    source.showImage(src);
    hough.showImage(colorDst);

    source.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    hough.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
Пример #6
0
  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;
  }