#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__