Example #1
0
  public IplImage correctGamma(IplImage img) {
    // get image intensity
    // img.applyGamma(d);
    IplImage gray = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1);
    cvCvtColor(img, gray, CV_RGB2GRAY);
    BufferedImage buffImg = img.getBufferedImage();
    BufferedImage buffGray = gray.getBufferedImage();
    double grayArr[] = new double[gray.width() * gray.height()];
    int counter = 0;
    for (int i = 0; i < gray.width(); i++) {
      for (int j = 0; j < gray.height(); j++) {
        grayArr[counter] = buffGray.getRGB(i, j);
        counter++;
      }
    }

    double imgSd = new StandardDeviation().evaluate(grayArr);
    double imgMean = new Mean().evaluate(grayArr);
    double y = 0;
    if (imgMean > 0.5) y = 1 + (Math.abs(0.5 - imgMean) / imgSd);
    else y = 1 / (1 + (Math.abs(0.5 - imgMean) / imgSd));

    img.applyGamma(y);

    return img;
  }
  /**
   * 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;
  }
Example #3
0
  public Histogram(IplImage img) {
    hist = new int[256];

    // calculate absolute values
    for (int i = 0; i < img.height(); i++) {
      for (int j = 0; j < img.width(); j++) {
        int val = (int) cvGetReal2D(img, i, j);
        hist[val]++;
      }
    }
  }
Example #4
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 boolean record(IplImage image, int pixelFormat) throws Exception {
    if (video_st == null) {
      throw new Exception(
          "No video output stream (Is imageWidth > 0 && imageHeight > 0 and has start() been called?)");
    }
    int ret;

    if (image == null) {
      /* no more frame to compress. The codec has a latency of a few
      frames if using B frames, so we get the last frames by
      passing the same picture again */
    } else {
      int width = image.width();
      int height = image.height();
      int step = image.widthStep();
      BytePointer data = image.imageData();

      if (pixelFormat == AV_PIX_FMT_NONE) {
        int depth = image.depth();
        int channels = image.nChannels();
        if ((depth == IPL_DEPTH_8U || depth == IPL_DEPTH_8S) && channels == 3) {
          pixelFormat = AV_PIX_FMT_BGR24;
        } else if ((depth == IPL_DEPTH_8U || depth == IPL_DEPTH_8S) && channels == 1) {
          pixelFormat = AV_PIX_FMT_GRAY8;
        } else if ((depth == IPL_DEPTH_16U || depth == IPL_DEPTH_16S) && channels == 1) {
          pixelFormat = AV_HAVE_BIGENDIAN() ? AV_PIX_FMT_GRAY16BE : AV_PIX_FMT_GRAY16LE;
        } else if ((depth == IPL_DEPTH_8U || depth == IPL_DEPTH_8S) && channels == 4) {
          pixelFormat = AV_PIX_FMT_RGBA;
        } else if ((depth == IPL_DEPTH_8U || depth == IPL_DEPTH_8S) && channels == 2) {
          pixelFormat = AV_PIX_FMT_NV21; // Android's camera capture format
          step = width;
        } else {
          throw new Exception(
              "Could not guess pixel format of image: depth=" + depth + ", channels=" + channels);
        }
      }

      if (video_c.pix_fmt() != pixelFormat
          || video_c.width() != width
          || video_c.height() != height) {
        /* convert to the codec pixel format if needed */
        img_convert_ctx =
            sws_getCachedContext(
                img_convert_ctx,
                width,
                height,
                pixelFormat,
                video_c.width(),
                video_c.height(),
                video_c.pix_fmt(),
                SWS_BILINEAR,
                null,
                null,
                null);
        if (img_convert_ctx == null) {
          throw new Exception(
              "sws_getCachedContext() error: Cannot initialize the conversion context.");
        }
        avpicture_fill(tmp_picture, data, pixelFormat, width, height);
        avpicture_fill(picture, picture_buf, video_c.pix_fmt(), video_c.width(), video_c.height());
        tmp_picture.linesize(0, step);
        sws_scale(
            img_convert_ctx,
            new PointerPointer(tmp_picture),
            tmp_picture.linesize(),
            0,
            height,
            new PointerPointer(picture),
            picture.linesize());
      } else {
        avpicture_fill(picture, data, pixelFormat, width, height);
        picture.linesize(0, step);
      }
    }

    if ((oformat.flags() & AVFMT_RAWPICTURE) != 0) {
      if (image == null) {
        return false;
      }
      /* raw video case. The API may change slightly in the future for that? */
      av_init_packet(video_pkt);
      video_pkt.flags(video_pkt.flags() | AV_PKT_FLAG_KEY);
      video_pkt.stream_index(video_st.index());
      video_pkt.data(new BytePointer(picture));
      video_pkt.size(Loader.sizeof(AVPicture.class));
    } else {
      /* encode the image */
      av_init_packet(video_pkt);
      video_pkt.data(video_outbuf);
      video_pkt.size(video_outbuf_size);
      picture.quality(video_c.global_quality());
      if ((ret =
              avcodec_encode_video2(
                  video_c, video_pkt, image == null ? null : picture, got_video_packet))
          < 0) {
        throw new Exception(
            "avcodec_encode_video2() error " + ret + ": Could not encode video packet.");
      }
      picture.pts(picture.pts() + 1); // magic required by libx264

      /* if zero size, it means the image was buffered */
      if (got_video_packet[0] != 0) {
        if (video_pkt.pts() != AV_NOPTS_VALUE) {
          video_pkt.pts(av_rescale_q(video_pkt.pts(), video_c.time_base(), video_st.time_base()));
        }
        if (video_pkt.dts() != AV_NOPTS_VALUE) {
          video_pkt.dts(av_rescale_q(video_pkt.dts(), video_c.time_base(), video_st.time_base()));
        }
        video_pkt.stream_index(video_st.index());
      } else {
        return false;
      }
    }

    synchronized (oc) {
      /* write the compressed frame in the media file */
      if (interleaved && audio_st != null) {
        if ((ret = av_interleaved_write_frame(oc, video_pkt)) < 0) {
          throw new Exception(
              "av_interleaved_write_frame() error "
                  + ret
                  + " while writing interleaved video frame.");
        }
      } else {
        if ((ret = av_write_frame(oc, video_pkt)) < 0) {
          throw new Exception("av_write_frame() error " + ret + " while writing video frame.");
        }
      }
    }
    return picture.key_frame() != 0;
  }
  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
Example #7
0
  public IplImage grab() throws Exception {
    if (pFormatCtx == null || pFormatCtx.isNull()) {
      throw new Exception("Could not grab: No AVFormatContext. (Has start() been called?)");
    }
    boolean done = false;
    long pts = 0;
    while (!done) {
      if (av_read_frame(pFormatCtx, packet) < 0) {
        // throw new Exception("Could not read frame");
        return null; // end of file?
      }

      // Is this a packet from the video stream?
      if (packet.stream_index() == videoStream) {
        // Decode video frame
        int len = avcodec_decode_video2(pCodecCtx, pFrame, frameFinished, packet);

        LongPointer opaque = new LongPointer(pFrame.opaque());
        if (packet.dts() != AV_NOPTS_VALUE) {
          pts = packet.dts();
        } else if (!opaque.isNull() && opaque.get() != AV_NOPTS_VALUE) {
          pts = opaque.get();
        } else {
          pts = 0;
        }
        AVRational time_base = pStream.time_base();
        pts = 1000 * pts * time_base.num() / time_base.den();

        // Did we get a video frame?
        if (len > 0 && frameFinished[0] != 0) {
          switch (colorMode) {
            case BGR:
            case GRAY:
              // Deinterlace Picture
              if (deinterlace) {
                avpicture_deinterlace(
                    pFrame, pFrame, pCodecCtx.pix_fmt(), pCodecCtx.width(), pCodecCtx.height());
              }

              // Convert the image from its native format to RGB
              sws_scale(
                  img_convert_ctx,
                  new PointerPointer(pFrame),
                  pFrame.linesize(),
                  0,
                  pCodecCtx.height(),
                  new PointerPointer(pFrameRGB),
                  pFrameRGB.linesize());
              return_image.imageData(buffer);
              return_image.widthStep(pFrameRGB.linesize(0));
              break;
            case RAW:
              assert (pCodecCtx.width() == return_image.width()
                  && pCodecCtx.height() == return_image.height());
              return_image.imageData(pFrame.data(0));
              return_image.widthStep(pFrame.linesize(0));
              break;
            default:
              assert (false);
          }
          return_image.imageSize(return_image.height() * return_image.widthStep());

          done = true;
        }
      }

      // Free the packet that was allocated by av_read_frame
      av_free_packet(packet);
    }

    return_image.timestamp = pts;
    return return_image;
  }
 public IplImage scale(IplImage img, int scale) {
   BufferedImage bi = resize(img.getBufferedImage(), img.width() / scale, img.height() / scale);
   ImageConverter ic = new ImageConverter();
   return ic.convertRGB(bi);
 }
Example #9
0
 public int getWidth() {
   return img.width();
 }
Example #10
0
 private static int clipX(IplImage img, double x) {
   return (int) Math.round(Math.min(Math.max(x, 0), img.width() - 1));
 }