[关闭]
@zimenglan 2015-03-27T08:53:59.000000Z 字数 16525 阅读 2132

human pose/joints annotation

human.pose annotation body.joints

使用说明

  1. 拷贝源码, 把它放到一个新建的jave project里面
  2. 运行(或者ctrl + F11), 会弹出一个框
  3. 将要标注的imageset扔到这个框里面去
  4. 剩下的就是开始标注图像了
  5. 需要注意的是, 在标完第一张的时候, 稍微等一两秒, 因为要生成对应的保存目录
  6. 源码只是在windows下测试过rgb图像和深度图

functions 介绍

保存格式

example

暂时不能从本地上传图片, 所有给不了标注时的效果图

code

  1. import java.awt.BasicStroke;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.Image;
  6. import java.awt.datatransfer.DataFlavor;
  8. import java.awt.dnd.DnDConstants;
  9. import java.awt.dnd.DropTarget;
  10. import java.awt.dnd.DropTargetDragEvent;
  11. import java.awt.dnd.DropTargetDropEvent;
  12. import java.awt.dnd.DropTargetEvent;
  13. import java.awt.dnd.DropTargetListener;
  15. import java.awt.event.KeyEvent;
  16. import java.awt.event.KeyListener;
  17. import java.awt.event.MouseAdapter;
  18. import java.awt.event.MouseEvent;
  19. import java.awt.event.MouseMotionAdapter;
  21. import java.io.BufferedWriter;
  22. import java.io.File;
  23. import java.io.FileWriter;
  25. import java.util.Arrays;
  26. import java.util.Iterator;
  27. import java.util.LinkedList;
  28. import java.util.List;
  30. import javax.imageio.ImageIO;
  31. import javax.swing.JFrame;
  32. import javax.swing.JOptionPane;
  36. public class PoseAnno_BB_And_Joints extends JFrame implements DropTargetListener {
  38.     private static final long serialVersionUID = 1L;
  40.     // one bounding box, and 15 body joints 
  41.     private static String[] annoName = {
  42.         // a bounding box for a whole person
  43.         "human_bb_top_left_cornor",
  44.         "human_bb_bottom_right_cornor",
  45.         // the body joints
  46.         "head", "neck", "torso",
  47.         "left_shoulder", "left_elbow", "left_hand/wrist",
  48.         "right_shoulder", "right_elbow", "right_hand/wrist", 
  49.         "left_hip", "left_knee", "left_foot/ankle",
  50.         "right_hip", "right_knee", "right_foot/ankle"
  51.     };
  53.     // 
  54.     private static int[] annoNameIndice = {
  55.         0, 1, 2, 3, 4, 
  56.         5, 6, 7, 8, 9, 10, 
  57.         11, 12, 13, 14, 15
  58.     };
  60.     // if the occluded area of the body part is more that 30 percentage,
  61.     // the body part is occluded
  62.     private static String[] occState = { 
  63.         "non_occ",  // default - 0
  64.         "occ"       // 1 
  65.     };
  67.     private Image offScreenImage = null; // avoid flicker
  68.     private Graphics gOffScreenGraphics;
  70.     // handler of the annotated image
  71.     private Image initImage = null;
  72.     // path to the annotated dataset
  73.     private String path = null;
  74.     private String _prePath = null;
  75.     private String _imagesetName = null;
  76.     // the image name without extension
  77.     private String fileName = null;
  78.     private String fileName2 = null;
  79.     private final String _labelExt = ".label";
  80.     private final String _saveDirExt = "_AnnoPose";
  81.     // image file list
  82.     private LinkedList<File> file_list = new LinkedList<File>();
  83.     // index of images
  84.     private int curFileIdx = 0;
  86.     // if shift is pressed, then draw
  87.     // horizontal or
  88.     // vertical line.
  89.     private boolean shift_flag = false; 
  91.     // flag to occlusion state
  92.     // 0: non-occluded, 1: occluded
  93.     private int[] isOccluded = new int[annoName.length];
  95.     // each part is annotated by one point
  96.     // private static final int numXY = 2;
  97.     // private int[][] xPoints = new int[annoName.length + 1][numXY];
  98.     // private int[][] yPoints = new int[annoName.length + 1][numXY];
  100.     // the first two points for human bounding box
  101.     // the rest for 15 human body joints
  102.     private final int totalLen = annoName.length;
  103.     private int[] xPoints = new int[totalLen];
  104.     private int[] yPoints = new int[totalLen];
  105.     // since human_bb occupies two points
  106.     private int[] points = new int[totalLen];
  108.     // index of parts
  109.     private int partsIdx = 0;
  111.     // initialize some variables
  112.     private static final double scale = 1;
  113.     private static final int _width = 640;
  114.     private static final int _height = 480;
  115.     private static final int _startX = 480;
  116.     private static final int _startY = 240;
  118.     private static final int _border = 10;
  119.     private static final int _startJframeX = 0;
  120.     private static final int _startJframeY = 20;
  121.     private static final int _circle_len = 5;
  123.     private static final String[] moustType = {
  124.         "left mouse button", 
  125.         "middle mouse wheel", 
  126.         "right mouse button"
  127.     };
  129.     // ***************************************************************
  132.     public PoseAnno_BB_And_Joints() {
  133.         // 
  134.         setTitle("Human Pose Annotation");
  135.         setSize(_width, _height);
  136.         setLocation(_startX, _startY);
  137.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  139.         // button 1: the left mouse button
  140.         // button 2: the mouse wheel
  141.         // button 3: the right mouse button
  142.         addMouseListener(new MouseAdapter() {
  143.             @Override
  144.             public void mouseClicked(MouseEvent e) {
  145.                 int type = e.getButton();
  146.                 System.out.println("mouse click type: " + moustType[type - 1]);
  147.                 System.out.println("partsIdx: " + partsIdx);
  149.                 if (initImage == null || partsIdx == totalLen || type == MouseEvent.BUTTON2) {
  150.                     return;
  151.                 }
  153.                 if (type == MouseEvent.BUTTON3) {
  154.                     xPoints[partsIdx] = 0;
  155.                     yPoints[partsIdx] = 0;
  157.                     // need to be reset
  158.                     if (partsIdx < 0) {
  159.                         Arrays.fill(isOccluded, 0);
  160.                         Arrays.fill(xPoints, 0);
  161.                         Arrays.fill(yPoints, 0);
  163.                         partsIdx = 0;
  164.                     }
  166.                     PoseAnno_BB_And_Joints.this.repaint();
  167.                     return;
  168.                 }
  170.                 // get the point location
  171.                 xPoints[partsIdx] = e.getX() - _startJframeX;
  172.                 yPoints[partsIdx] = e.getY() - _startJframeY;
  174.                 // System.out.println("mouse click point: (" + 
  175.                 //      e.getX() + ", " + e.getY() + ")");
  176.                 System.out.println("mouse click point: (" + xPoints[partsIdx] + 
  177.                         ", " + yPoints[partsIdx] + ")");
  179.                 if (xPoints[partsIdx] < _border) {
  180.                     xPoints[partsIdx] = _border;
  181.                 }
  182.                 if (xPoints[partsIdx] >= initImage.getWidth(null) + _border) {
  183.                     xPoints[partsIdx] = initImage.getWidth(null) + _border - 1;
  184.                 }
  186.                 if (yPoints[partsIdx] < _border) {
  187.                     yPoints[partsIdx] = _border;
  188.                 }
  189.                 if (yPoints[partsIdx] >= initImage.getHeight(null) + _border) {
  190.                     yPoints[partsIdx] = initImage.getHeight(null) + _border - 1;
  191.                 }
  193.                 // isOccluded[partsIdx] = 0;
  194.                 // 
  195.                 partsIdx++;
  197.                 // repaint
  198.                 PoseAnno_BB_And_Joints.this.repaint();
  200.                 // 
  201.                 if (partsIdx == totalLen) {
  202.                     int choice = JOptionPane.showConfirmDialog(
  203.                             PoseAnno_BB_And_Joints.this,
  204.                             "complete! save annotation or not?", 
  205.                             "tips",
  206.                             JOptionPane.YES_NO_OPTION
  207.                     );
  208.                     if (choice == JOptionPane.YES_OPTION) {
  209.                         // save the annotation
  210.                         saveAnnotation();
  212.                         // set next image
  213.                         if (file_list.size() > 1) {
  214.                             setNextPic(1);
  215.                         }
  216.                     }
  217.                 }
  218.             }
  219.         });
  221.         addMouseMotionListener(new MouseMotionAdapter() {
  222.             @Override
  223.             public void mouseMoved(MouseEvent e) {
  224.                 /*if (initImage == null || partsIdx == totalLen) {
  225.                     return;
  226.                 }*/
  228.                 // only for drawing a bounding box for the whole person
  229.                 // not for the 15 body joints
  230.                 if (initImage == null || partsIdx > 1) {
  231.                     return;
  232.                 }
  234.                 // System.out.println("mouse move");
  236.                 // get the point location -- keep lineIdx 
  237.                 xPoints[partsIdx] = e.getX() - _startJframeX;
  238.                 yPoints[partsIdx] = e.getY() - _startJframeY;
  240.                 // System.out.println("mouse move point: (" + e.getX() + 
  241.                 //          ", " + e.getY() + ")");
  242.                 System.out.println("mouse click point: (" + xPoints[partsIdx] 
  243.                         + ", " + yPoints[partsIdx] + ")");
  245.                 if (xPoints[partsIdx] < _border) {
  246.                     xPoints[partsIdx] = _border;
  247.                 }
  248.                 if (xPoints[partsIdx] >= initImage.getWidth(null) + _border) {
  249.                     xPoints[partsIdx] = initImage.getWidth(null) + _border - 1;
  250.                 }
  252.                 if (yPoints[partsIdx] < _border) {
  253.                     yPoints[partsIdx] = _border;
  254.                 }
  255.                 if (yPoints[partsIdx] >= initImage.getHeight(null) + _border) {
  256.                     yPoints[partsIdx] = initImage.getHeight(null) + _border - 1;
  257.                 }
  259.                 // repaint
  260.                 repaint();
  261.             }
  262.         });
  264.         // o: 0: non-occluded, 1: occluded
  265.         // u: back to pre joint
  266.         // n: ahead to next-joint
  267.         // r: reset the current image
  268.         // s: save the current anno info
  269.         // a: back to pre image
  270.         // d: ahead to next image
  271.         addKeyListener(new KeyListener() {
  272.             @Override
  273.             public void keyTyped(KeyEvent e) {
  274.             }
  276.             // dose not modify
  277.             @Override
  278.             public void keyReleased(KeyEvent e) {
  279.                 switch (e.getKeyCode()) {
  280.                 case KeyEvent.VK_SHIFT:
  281.                     shift_flag = false;
  282.                     break;
  283.                 }
  284.             }
  286.             // need to be modified
  287.             @Override
  288.             public void keyPressed(KeyEvent e) {
  289.                 switch (Character.toLowerCase(e.getKeyChar())) {
  290.                 //  back to pre-part
  291.                 case 'u':
  292.                     if (partsIdx != 0) {
  293.                         System.out.println("u(back to the pre joint):" + " " + annoName[partsIdx]);
  295.                         // current part -- need to be reset
  296.                         xPoints[partsIdx] = 0;
  297.                         yPoints[partsIdx] = 0;
  298.                         isOccluded[partsIdx] = 0;   // set to be non-occlusion
  300.                         partsIdx--;
  302.                         // need to be reset
  303.                         if (partsIdx < 0) {
  304.                             Arrays.fill(isOccluded, 0);
  305.                             Arrays.fill(xPoints, 0);
  306.                             Arrays.fill(yPoints, 0);
  308.                             partsIdx = 0;
  309.                             return;
  310.                         }
  312.                         // current part -- need to be reset
  313.                         // really need?
  314.                         xPoints[partsIdx] = 0;
  315.                         yPoints[partsIdx] = 0;
  316.                         isOccluded[partsIdx] = 0;   // set to be non-occlusion
  317.                     }
  318.                     break;
  320.                 // save the annotation
  321.                 case 's':
  322.                     System.out.println("s(save)" + " " + file_list.get(curFileIdx));
  323.                     saveAnnotation();
  325.                     // set and init next image
  326.                     if (file_list.size() > 1) {
  327.                         setNextPic(1);
  328.                     }
  329.                     break;
  331.                 // ahead to next part
  332.                 case 'n':
  333.                     // skip current annotation due to missing
  334.                     if (partsIdx >= annoName.length)
  335.                         return;
  336.                     System.out.println("n(next joint): " + " " + annoName[partsIdx]);
  338.                     xPoints[partsIdx] = 0;
  339.                     yPoints[partsIdx] = 0;
  340.                     // set to be occlusion since you ignore the current part
  341.                     isOccluded[partsIdx] = 1;   
  343.                     partsIdx++;
  344.                     if (partsIdx == totalLen) {
  345.                         int choice = JOptionPane.showConfirmDialog(
  346.                                 PoseAnno_BB_And_Joints.this,
  347.                                 "complete! save annotation or not?", "tips",
  348.                                 JOptionPane.YES_NO_OPTION
  349.                                 );
  351.                         if (choice == JOptionPane.YES_OPTION) {
  352.                             // 
  353.                             saveAnnotation();
  355.                             // set and init next image
  356.                             // if (file_list.size() > 1) {
  357.                                 // setNextPic(1);
  358.                             // }
  359.                         }
  360.                     }
  361.                     break;
  363.                 // back to pre image
  364.                 case 'a':
  365.                     // back to pre image and init pre image status
  366.                     System.out.println("a(back from):" + " " + file_list.get(curFileIdx));
  368.                     // remove the current label file, if it exist
  369.                     String annoPath = _prePath + "/" + _imagesetName + _saveDirExt;
  370.                     File file = new File(annoPath);
  371.                     file.mkdir();
  372.                     String annoLabelFile = annoPath + "/" + fileName + _labelExt;
  373.                     file = new File(annoLabelFile);
  374.                     if(file.exists()) {
  375.                         file.delete();
  376.                     }
  378.                     // then back to pre image
  379.                     setNextPic(0);
  380.                     break;
  382.                 // ahead to next image
  383.                 case 'd':
  384.                     // set and init next image status
  385.                     // saveAnnotation();   
  386.                     // just ignore the current image
  387.                     System.out.println("d(ahead to):" + " " + file_list.get(curFileIdx));
  388.                     setNextPic(1);
  389.                     break;
  391.                 // reset the current image
  392.                 case 'r':
  393.                     System.out.println("r(rest):" + " " + file_list.get(curFileIdx));
  395.                     partsIdx = 0;
  396.                     Arrays.fill(xPoints, 0);
  397.                     Arrays.fill(yPoints, 0);
  398.                     Arrays.fill(isOccluded, 0);
  399.                     break;
  401.                 // 1: partial occluded
  402.                 case 'o':
  403.                     System.out.println("if the part is occluded, you should " +
  404.                             "press the 'o' key before click the mouse");
  405.                     System.out.println("o(occ): " + " " + annoName[partsIdx]);
  406.                     isOccluded[partsIdx] = 1;
  407.                     break;
  409.                 default:
  410.                     switch (e.getKeyCode()) {
  411.                     case KeyEvent.VK_ESCAPE:
  412.                         xPoints[partsIdx] = 0;
  413.                         yPoints[partsIdx] = 0;
  414.                         isOccluded[partsIdx] = 1;   // set to be non-occlusion
  415.                         break;
  417.                     case KeyEvent.VK_SHIFT:
  418.                         shift_flag = true;
  419.                         break;
  420.                     }
  421.                 }
  423.                 // repaint
  424.                 PoseAnno_BB_And_Joints.this.repaint();
  425.             }
  426.         });
  428.         new DropTarget(this, this);
  430.         setVisible(true);
  431.     }
  433.     protected void saveAnnotation() {
  434.         saveAnnoPose();
  435.     }
  437.     protected void saveAnnoPose() {
  438.         try {
  439.             String annoPath = _prePath + "/" + _imagesetName + _saveDirExt;
  440.             File file = new File(annoPath);
  441.             file.mkdir();
  442.             String annoLabelFile = annoPath + "/" + fileName + _labelExt;
  443.             file = new File(annoLabelFile);
  444.             BufferedWriter bw = new BufferedWriter(new FileWriter(file));
  446.             // the total path to the image
  447.             String str = fileName2 + "\n";
  448.             double x1, y1;
  450.             // body joints
  451.             for (int i = 0; i < totalLen - 1; i++) {
  452.                 x1 = Math.max( (xPoints[i] - _border) / scale, 0 ); 
  453.                 y1 = Math.max( (yPoints[i] - _border) / scale, 0 );
  454.                 str = str + annoName[i] + " " + x1 + " " + y1 + " " 
  455.                         + isOccluded[i] + "\n";
  456.             }
  458.             x1 = Math.max( (xPoints[totalLen - 1] - _border) / scale, 0 );  
  459.             y1 = Math.max( (yPoints[totalLen - 1] - _border) / scale, 0 );
  460.             str = str + annoName[totalLen - 1] + " " + x1 + " " + y1 + " " 
  461.                     + isOccluded[totalLen - 1];
  462.             str = str + "\n";
  464.             bw.write(str);
  465.             bw.close();
  467.         } catch (Exception e) {
  468.             e.printStackTrace();
  469.             JOptionPane.showMessageDialog(this, "failed to save annotation");
  470.         }
  471.     }
  473.     @Override
  474.     public void update(Graphics g) {
  475.         if (initImage == null)
  476.             return;
  478.         if (offScreenImage == null
  479.                 || offScreenImage.getHeight(this) != this.getHeight()
  480.                 || offScreenImage.getWidth(this) != this.getWidth() ) {
  482.             offScreenImage = this.createImage(this.getWidth(), this.getHeight());
  484.             gOffScreenGraphics = offScreenImage.getGraphics();
  485.         }
  487.         int imgWidth = initImage.getWidth(null);
  488.         int imgHeigth = initImage.getHeight(null);
  490.         int osImgWidth = offScreenImage.getWidth(null);
  491.         int osImgHeight = offScreenImage.getHeight(null);
  493.         System.out.println("imgWidth: " + imgWidth + ", imgHeight: " + imgHeigth + 
  494.                 ", oImgWidth: " + osImgWidth + ", oImgHeight: " + osImgHeight);
  496.         // a top-left corner (_border, _border)
  497.         gOffScreenGraphics.drawImage(initImage, _border, _border, this); 
  499.         ((Graphics2D) gOffScreenGraphics).setStroke(new BasicStroke(1.50f));
  500.         gOffScreenGraphics.setColor(Color.GREEN);
  502.         if (partsIdx < totalLen) {
  503.             gOffScreenGraphics.drawString("" + partsIdx + ": " + annoName[partsIdx], 20, 20);
  504.         } else {
  505.             gOffScreenGraphics.drawString("" + partsIdx + ": " + 
  506.                     "annotatation has been done!", 20, 50);
  507.         }
  509.         gOffScreenGraphics.setColor(Color.ORANGE);
  510.         // draw the current line
  511.         int i;
  512.         // draw the joints
  513.         for(i = 0; i < partsIdx; i++) {
  514.             gOffScreenGraphics.fillOval(xPoints[i], yPoints[i], _circle_len, _circle_len);
  515.         }
  517.         // draw the bounding box for human
  518.         gOffScreenGraphics.setColor(Color.RED);
  519.         if(partsIdx > 1) {
  520.             int lineX[] = {xPoints[0], xPoints[0], xPoints[1], xPoints[1], xPoints[0]};
  521.             int lineY[] = {yPoints[0], yPoints[1], yPoints[1], yPoints[0], yPoints[0]};
  522.             for (i = 0; i < lineX.length - 1; i++) {
  523.                 gOffScreenGraphics.drawLine(lineX[i], lineY[i], lineX[i + 1], lineY[i + 1]);
  524.             }
  525.         }
  527.         // paint(gOffScreen);
  528.         g.drawImage(offScreenImage, _startJframeX, _startJframeY, this);
  529.         g.dispose();
  530.     }
  532.     @Override
  533.     public void paint(Graphics g) {
  534.         update(g);
  535.     }
  537.     // *********************************************
  538.     @Override
  539.     public void dragEnter(DropTargetDragEvent dtde) {
  541.     }
  543.     @Override
  544.     public void dragOver(DropTargetDragEvent dtde) {
  546.     }
  548.     @Override
  549.     public void dropActionChanged(DropTargetDragEvent dtde) {
  551.     }
  553.     @Override
  554.     public void dragExit(DropTargetEvent dte) {
  556.     }
  557.     // *******************************************
  559.     // drop the images into UI
  560.     // get the image file list
  561.     @SuppressWarnings("rawtypes")
  562.     @Override
  563.     public void drop(DropTargetDropEvent dtde) {
  564.         try {
  565.             if (dtde.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
  566.                 dtde.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
  568.                 List list = (List) (dtde.getTransferable()
  569.                         .getTransferData(DataFlavor.javaFileListFlavor));
  571.                 Iterator iterator = list.iterator();
  572.                 file_list.clear();
  573.                 curFileIdx = -1;
  575.                 while (iterator.hasNext()) {
  576.                     File file = (File) iterator.next();
  577.                     if (file.isDirectory()) {
  578.                         addFileToQueue(file);
  579.                     } else {
  580.                         if (file.getName().endsWith(".jpg") || 
  581.                                 file.getName().endsWith(".png"))
  582.                             file_list.add(file);
  583.                     }
  584.                 }
  586.                 // start & init
  587.                 setNextPic(1);
  588.                 dtde.dropComplete(true);
  589.             } else {
  590.                 dtde.rejectDrop();
  591.             }
  592.         } catch (Exception e) {
  593.             e.printStackTrace();
  594.             dtde.rejectDrop();
  595.             JOptionPane.showMessageDialog(this, "Failed to open images");
  596.         }
  597.     }
  599.     // flag == 0 -- previous pic
  600.     // flag == 1 -- next pic
  601.     private void setNextPic(int flag) {
  602.         int tmp = curFileIdx;
  604.         // back
  605.         if (flag == 0) {
  606.             if (curFileIdx == 0) {
  607.                 JOptionPane.showMessageDialog(this, "The first one!");
  608.                 return;
  609.             }
  610.             curFileIdx--;
  611.         } else {
  612.             // next
  613.             curFileIdx++;
  614.         }
  616.         boolean ok = false;
  617.         while (!ok) {
  618.             try {
  619.                 if (curFileIdx >= file_list.size()) {
  620.                     curFileIdx = tmp;
  621.                     if (curFileIdx == -1)
  622.                         return;
  623.                     JOptionPane.showMessageDialog(this, "The last one!");
  624.                     return;
  625.                 }
  626.                 File file = file_list.get(curFileIdx);
  628.                 initImage = ImageIO.read(file);
  630.                 initImage = initImage.getScaledInstance(
  631.                     (int) (initImage.getWidth(null) * scale),
  632.                     (int) (initImage.getHeight(null) * scale),
  633.                     Image.SCALE_SMOOTH  // SCALE_DEFAULT, SCALE_SMOOTH
  634.                 );      
  636.                 // path and fileName
  637.                 int idx;
  638.                 path = file.getParent();
  639.                 String fileSeparator = System.getProperty("file.separator");
  640.                 // idx = path.lastIndexOf('\\');    // here is '\'
  641.                 idx = path.lastIndexOf(fileSeparator);  // here is '\'
  642.                 System.out.println("idx " + idx);
  643.                 System.out.println("fileSeparator " + fileSeparator);
  644.                 System.out.println("path " + path);
  645.                 if(idx != 0){
  646.                     _prePath = path.substring(0, idx);
  647.                     _imagesetName = path.substring(idx + 1);
  648.                 }
  650.                 int imgLen = file_list.size();
  651.                 fileName = file.getName();
  652.                 fileName2 = path + fileSeparator + file.getName();
  653.                 idx = fileName.lastIndexOf('.');
  654.                 if (idx != -1) {
  655.                     fileName = fileName.substring(0, idx);
  656.                 }
  657.                 setTitle(fileName + " in " + imgLen + " imageset");
  659.                 // 
  660.                 partsIdx = 0;
  662.                 // set default value - 0: non_occ, 1: occ
  663.                 Arrays.fill(isOccluded, 0);
  664.                 // 1 bb for person and 15 joints
  665.                 Arrays.fill(points, 0);
  667.                 Arrays.fill(xPoints, 0);
  668.                 Arrays.fill(yPoints, 0);
  670.                 // _border: 10
  671.                 // _startJframeX: 0
  672.                 // _startJframeY: 20
  673.                 setSize(initImage.getWidth(null)  + _border * 3 + _startJframeX,
  674.                     initImage.getHeight(null) + _border * 3 + _startJframeY
  675.                 );
  677.                 // readAnnotation(path + "/Annotations/" + fileName + ".xml");
  678.                 repaint();
  680.                 ok = true;
  682.             } catch (Exception e) {
  683.                 e.printStackTrace();
  684.                 if (flag == 0) {
  685.                     if (curFileIdx == 0) {
  686.                         return;
  687.                     }
  688.                     curFileIdx--;
  689.                 } else {
  690.                     curFileIdx++;
  691.                 }
  692.             }
  693.         }
  694.     }
  696.     // add file to file_list
  697.     // if meet folder then recur it
  698.     private void addFileToQueue(File folder) {
  699.         for (File file : folder.listFiles()) {
  700.             if (file.isDirectory()) {
  701.                 addFileToQueue(file);
  702.             } else {
  703.                 if (file.getName().endsWith(".jpg") || file.getName().endsWith(".png")) {
  704.                     file_list.add(file);
  705.                 }
  706.             }
  707.         }
  708.     }
  710.     // here we don't use it
  711.     private boolean readAnnotation(String path) {
  712.         File gt = new File(path);
  713.         if (!gt.exists())
  714.             return false;
  716.         int choice = JOptionPane.showConfirmDialog(this,
  717.                 "Annotation file is found, read it or not?", "tips",
  718.                 JOptionPane.YES_NO_OPTION);
  719.         if (choice != JOptionPane.YES_OPTION)
  720.             return false;
  722.         try {
  723.             // ??
  724.         } catch (Exception e) {
  725.             e.printStackTrace();
  726.             partsIdx = 0;
  727.             Arrays.fill(xPoints, 0);
  728.             Arrays.fill(yPoints, 0);
  729.             Arrays.fill(isOccluded, 0);
  730.             JOptionPane.showMessageDialog(this, "Invalid annotation file");
  731.         }
  732.         return true;
  733.     }
  736.     // **********************************************
  739.     public static void main(String[] args) {
  740.         new PoseAnno_BB_And_Joints();
  741.     }
  743. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注