opencv_traincascade.exe -data haar -vec samples.vec
  -bg bad.txt -numStages 16 -minHitRate 0.99
  -maxFalseAlarmRate 0.4 -numPos 550 -numNeg 1594 -w 43 -h 30
  

  import org.bytedeco.javacpp.opencv_core;
  import org.bytedeco.javacpp.opencv_imgproc;
  import org.bytedeco.javacpp.opencv_objdetect;
  
  import java.nio.ByteBuffer;
  
  import static org.bytedeco.javacpp.opencv_imgcodecs.CV_LOAD_IMAGE_GRAYSCALE;
  import static org.bytedeco.javacpp.opencv_imgcodecs.imread;
  import static org.bytedeco.javacpp.opencv_imgcodecs.imwrite;
  import static org.bytedeco.javacpp.opencv_imgproc.rectangle;
  
  /**
   * Created by Kos on 21.08.2015.
   */
  public class SignDetector {
  
      private final int squareDeviation;
      private opencv_objdetect.CascadeClassifier classifier;
  
      /**
       * Detector creation
       * @param cascadeFileName - cascade file name
       * @param deviationLevel - standard deviation limit
       */
      public SignDetector(String cascadeFileName, int deviationLevel) {
          classifier = new opencv_objdetect.CascadeClassifier(cascadeFileName);
          this.squareDeviation = deviationLevel*deviationLevel;
      }
  
      /**
       * Checks if a sign exists
       * @param srcFName - input scan filename
       * @param drawFileName - result filename (for debug)
       * @return
       */
       public boolean detectSign(String srcFName, String drawFileName) {
          //read an image from file
          opencv_core.Mat mat = imread(srcFName, CV_LOAD_IMAGE_GRAYSCALE);
  
          // The coordinates store for detected areas
          opencv_core.RectVector rectVector = new opencv_core.RectVector();
  
          // Finding a sign area
          classifier.detectMultiScale(mat, rectVector);
          boolean hasFound = rectVector.size() > 0;
  
          if (!hasFound) {
              // if nothing was found lets try to transform and find again
              opencv_core.Mat equalized = new opencv_core.Mat();
              opencv_imgproc.equalizeHist(mat, equalized);
              classifier.detectMultiScale(equalized, rectVector);
              hasFound = rectVector.size() > 0;
          }
          if (hasFound) {
              // Find the biggest area and reduce it
              opencv_core.Rect rect = reduceTwice(getMaxRect(rectVector));
              if (drawFileName != null) {
                  // draw work area and save to separate file
                  drawRect(mat, drawFileName, rect);
              }
              // sign searching in the area
              return searchSign(mat, rect);
          }
          System.out.println("Sign place is not found");
          return false;
      }
  
      /**
       * Draws a rectangle and saves it to a file
       * @param mat - input matrix
       * @param resultFName - filename to save
       * @param rect - rectangle
       */
      private void drawRect(opencv_core.Mat mat, String resultFName, opencv_core.Rect rect) {
          int height = rect.height();
          int width = rect.width();
          int x = rect.tl().x();
          int y = rect.tl().y();
          opencv_core.Point start = new opencv_core.Point(x, y);
          opencv_core.Point finish = new opencv_core.Point(x+width, y + height);
          rectangle(mat, start, finish, opencv_core.Scalar.all(0));
          imwrite(resultFName, mat);
      }
  
      /**
       * Sign searching in a fragment of an image
       * @param mat - input matrix
       * @param rect - searching rectangle
       * @return
       */
      private boolean searchSign(opencv_core.Mat mat, opencv_core.Rect rect) {
          int x0 = rect.x();
          int y0 = rect.y();
          int x1 = rect.width() + x0;
          int y1 = rect.height() + y0;
          ByteBuffer byteBuffer = mat.getByteBuffer();
  
          // calcution average blackness of pixels
          long blackness = 0;
          for (int y = y0; y <= y1; y++) {
              for (int x = x0; x <= x1; x++) {
                  long index = y*mat.step() + x*mat.channels();
                  int color = byteBuffer.get((int)index) & 0xFF;
                  blackness += (255 - color);
              }
          }
  
          float background = blackness/rect.width()/rect.height();
  
          // calculating standard deviation
          long squareDev = 0;
          for (int y = y0; y <= y1; y++) {
              for (int x = x0; x <= x1; x++) {
                  long index = y*mat.step() + x*mat.channels();
                  int color = byteBuffer.get((int)index) & 0xFF;
                  squareDev += (background - (255-color))*(background - (255-color));
              }
          }
          squareDev = squareDev/rect.width()/rect.height();
  
          return squareDev > squareDeviation;
      }
  
      /**
       * Returns the largest rectangle
       * @param rectVector
       * @return
       */
      private opencv_core.Rect getMaxRect(opencv_core.RectVector rectVector) {
          int maxWidth = 0;
          opencv_core.Rect result = null;
          for (int i = 0; i <= rectVector.size(); i++) {
              opencv_core.Rect currentRect = rectVector.get(i);
              int width = currentRect.width();
              if (width > maxWidth) {
                  maxWidth = width;
                  result = currentRect;
              }
          }
          return result;
      }
  
      /**
       * Reduces a rectangle
       * @param big
       * @return
       */
      private opencv_core.Rect reduceTwice(opencv_core.Rect big) {
          int height = big.height();
          int width = big.width();
          int x = big.tl().x();
          int y = big.tl().y();
          return new opencv_core.Rect(x+width/4, y+height/4, width/2, height/2);
      }
  }