LinesSampler.h Example File

 #ifndef __LINESSAMPLER_H__
 #define __LINESSAMPLER_H__

 /*
  * Copyright 2010 ZXing authors All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <map>
 #include <zxing/common/BitMatrix.h>
 #include <zxing/ResultPoint.h>
 #include <zxing/common/Point.h>

 namespace zxing {
 namespace pdf417 {
 namespace detector {

 class LinesSampler {
 private:
   static const int MODULES_IN_SYMBOL = 17;
   static const int BARS_IN_SYMBOL = 8;
   static const int POSSIBLE_SYMBOLS = 2787;
   static const std::vector<float> RATIOS_TABLE;
   static std::vector<float> init_ratios_table();
   static const int BARCODE_START_OFFSET = 2;

   Ref<BitMatrix> linesMatrix_;
   int symbolsPerLine_;
   int dimension_;

   static std::vector<Ref<ResultPoint> > findVertices(Ref<BitMatrix> matrix, int rowStep);
   static std::vector<Ref<ResultPoint> > findVertices180(Ref<BitMatrix> matrix, int rowStep);

   static ArrayRef<int> findGuardPattern(Ref<BitMatrix> matrix,
                                         int column,
                                         int row,
                                         int width,
                                         bool whiteFirst,
                                         const int pattern[],
                                         int patternSize,
                                         ArrayRef<int> counters);
   static int patternMatchVariance(ArrayRef<int> counters, const int pattern[],
                                   int maxIndividualVariance);

   static void correctVertices(Ref<BitMatrix> matrix,
                               std::vector<Ref<ResultPoint> > &vertices,
                               bool upsideDown);
   static void findWideBarTopBottom(Ref<BitMatrix> matrix,
                                    std::vector<Ref<ResultPoint> > &vertices,
                                    int offsetVertice,
                                    int startWideBar,
                                    int lenWideBar,
                                    int lenPattern,
                                    int nIncrement);
   static void findCrossingPoint(std::vector<Ref<ResultPoint> > &vertices,
                                 int idxResult,
                                 int idxLineA1,int idxLineA2,
                                 int idxLineB1,int idxLineB2,
                                 Ref<BitMatrix> matrix);
   static float computeModuleWidth(std::vector<Ref<ResultPoint> > &vertices);
   static int computeDimension(Ref<ResultPoint> topLeft,
                               Ref<ResultPoint> topRight,
                               Ref<ResultPoint> bottomLeft,
                               Ref<ResultPoint> bottomRight,
                               float moduleWidth);
   int computeYDimension(Ref<ResultPoint> topLeft,
                         Ref<ResultPoint> topRight,
                         Ref<ResultPoint> bottomLeft,
                         Ref<ResultPoint> bottomRight,
                         float moduleWidth);

    Ref<BitMatrix> sampleLines(std::vector<Ref<ResultPoint> > const &vertices,
                               int dimensionY,
                               int dimension);

   static void codewordsToBitMatrix(std::vector<std::vector<int> > &codewords,
                                    Ref<BitMatrix> &matrix);
   static int calculateClusterNumber(int codeword);
   static Ref<BitMatrix> sampleGrid(Ref<BitMatrix> image,
                                    int dimension);
   static void computeSymbolWidths(std::vector<float>& symbolWidths,
                                   const int symbolsPerLine, Ref<BitMatrix> linesMatrix);
   static void linesMatrixToCodewords(std::vector<std::vector<int> > &clusterNumbers,
                                      const int symbolsPerLine,
                                      const std::vector<float> &symbolWidths,
                                      Ref<BitMatrix> linesMatrix,
                                      std::vector<std::vector<int> > &codewords);
   static std::vector<std::vector<std::map<int, int> > >
       distributeVotes(const int symbolsPerLine,
                       const std::vector<std::vector<int> >& codewords,
                       const std::vector<std::vector<int> >& clusterNumbers);
   static std::vector<int>
       findMissingLines(const int symbolsPerLine,
                        std::vector<std::vector<int> > &detectedCodeWords);
   static int decodeRowCount(const int symbolsPerLine,
                             std::vector<std::vector<int> > &detectedCodeWords,
                             std::vector<int> &insertLinesAt);

   static int round(float d);
   static Point intersection(Line a, Line b);

 public:
   LinesSampler(Ref<BitMatrix> linesMatrix, int dimension);
   Ref<BitMatrix> sample();
 };

 }
 }
 }

 #endif // __LINESSAMPLER_H__