getLines.cpp

Go to the documentation of this file.

#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <boost/lexical_cast.hpp>
#include <ros/package.h>
#include <algorithm>
#include <stdio.h>
#include <string>
#include <iostream>
#include <stdlib.h>
#include <fstream>
#include <utility>
#include <assert.h>
#include <portrait_painter/getLines.h>

using namespace cv;
using namespace std;
using namespace portrait_painter;

GetLines::GetLines() {
        _size = -1;
        params.turdSize = 2;
        params.maxDistance = 1000;
        params.maxDistanceBetweenPoints = 3;
        params.maxDistanceBetweenLines = 1000;
        params.minDistanceWithinVector = 2;
        params.minLineSize = 1;
        params.invert = true;
        params.splitFactor = 7;
        params.threshold = 5;
}

vector<pair<CvPoint2D32f, vector<CvPoint2D32f> > > GetLines::getLines(
                string& image) {
        assert(image.length() > 0);
        vector<string> file;
        src = imread(image, CV_LOAD_IMAGE_GRAYSCALE);

        if (params.maxDistanceBetweenLines == 1000)
                params.maxDistanceBetweenLines = src.rows / 70;
        if (params.maxDistance == 1000)
                params.maxDistance = src.rows / 200;
        //thinContours(image);
        readInFile(image, &file);
        // Now analyse the string vector
        // The first two characters describe what to do next

        CvPoint2D32f absolute, absoluteTmp;
        bool penUp = true;
        bool newLine = false;
        size_t numOfPoints = 0;
        vector<CvPoint2D32f> relative;
        for (size_t i = 0; i < file.size(); i++) {
                // Get the hpglCommand and erase it from the line
                if (file[i][0] == '\n')
                        file[i].erase(0, 1);
                string hpglCode = file[i].substr(0, 2);
                file[i].erase(0, 2);

                if (hpglCode == "PM") // Polygon Mode
                                {
                } else if (hpglCode == "PA") // abs. Coords
                                {
                        // New line. Set the absolute point to the coords.
                        int comma = file[i].find(",");
                        absoluteTmp.x = atoi(file[i].substr(0, comma).c_str()) - 1;
                        absoluteTmp.y = src.rows
                                        - (atoi(file[i].substr(comma + 1).c_str()) - 1);

                        newLine = true;
                        penUp = false;
                } else if (hpglCode == "PD") // Pen down
                                {
                        // Obviously the pen is down.
                        penUp = false;
                        // If it is really a new line, push into vector and set
                        // the new absolute point
                        if (!relative.empty() && newLine) {
                                numOfPoints += relative.size();
                                lines.push_back(make_pair(absolute, relative));
                                relative.clear();
                        }
                        if (newLine) {
                                relative.clear();
                                absolute = absoluteTmp;
                                newLine = false;
                        }
                        // Get all the relative Coords.
                        for (size_t j = 0; j < file[i].size(); j++) {
                                // Therefore find the first two commas.
                                // The first is separating x and y and the second
                                // is the end of y. After storing them go on starting
                                // from the second comma.
                                size_t commaFirst = file[i].find(",", j + 1);
                                if (commaFirst == string::npos)
                                        break;
                                size_t commaSecond = file[i].find(",", commaFirst + 1);
                                string points = file[i].substr(j, commaSecond - j);
                                CvPoint2D32f point;
                                point.x = atoi(points.substr(0, commaFirst - j).c_str());
                                point.y = -atoi(points.substr(commaFirst + 1 - j).c_str());
                                relative.push_back(point);
                                absoluteTmp.x += point.x;
                                absoluteTmp.y += point.y;
                                if (commaSecond == string::npos)
                                        break;
                                j = commaSecond;
                        }
                } else if (hpglCode == "PU") // Pen up
                                {
                        penUp = true;
                } else if (hpglCode == "PR") // rel. Coords
                                {
                        // Be sure something should be done.
                        if (!penUp)
                                continue;
                        // Now get the relative Coords.
                        // If they are smaller than the threshold, don't
                        // put the pen up, just go on.
                        size_t comma = file[i].find(",");
                        CvPoint2D32f point;
                        point.x = atoi(file[i].substr(0, comma).c_str());
                        point.y = -atoi(file[i].substr(comma + 1).c_str());
                        newLine = true;
                        absoluteTmp.x += point.x;
                        absoluteTmp.y += point.y;
                        penUp = false;
                } else if (hpglCode == "EP") // Edge Polygon
                                {
                } else if (hpglCode == "FP") // Fill Polygon
                                {
                } else if (hpglCode == "IN") // Initialize
                                {
                }
        }
        // Since the last vector is not pushed back, so it manually.
        lines.push_back(make_pair(absolute, relative));
        minimize();
        return lines;
}

void GetLines::minimize() {
        size_t numOfLines = lines.size();
        size_t numOfPoints = 0;
        // Count number of points.
        for (size_t i = 0; i < lines.size(); i++)
                numOfPoints += lines[i].second.size();

        cout << "Num of points before minimizing: " << numOfPoints << endl;
        cout << "Num of lines before minimizing: " << numOfLines << endl;

        // Now minimize the number of lines.
        eraseDoubleLines(params.maxDistanceBetweenPoints);
        connectLines(params.maxDistanceBetweenLines, lines);
        minimizeLines(params.maxDistance, params.threshold);

        numOfLines = lines.size();
        numOfPoints = 0;
        // Count number of points.
        for (size_t i = 0; i < lines.size(); i++)
                numOfPoints += lines[i].second.size();

        cout << "Num of lines after minimizing: " << lines.size() << endl;
        cout << "Num of points after minimizing: " << numOfPoints << endl;
}

void GetLines::minimizeLines(size_t maxDistance, size_t threshold) {
        // If lines are very similiar, just say it is one line.
        for (size_t i = 0; i < lines.size(); i++) {
                // Initialize.
                CvPoint2D32f newPoint;
                newPoint.x = 0;
                newPoint.y = 0;
                unsigned int num = 0;
                int start = -1;
                for (size_t j = 0; j < lines[i].second.size(); j++) {
                        CvPoint2D32f actPoint = lines[i].second[j];
                        size_t distance = sqrt(
                                        newPoint.x * newPoint.x + newPoint.y * newPoint.y);
                        if (distance <= maxDistance
                                        && num <= lines[i].second.size() / threshold) {
                                if (start == -1)
                                        start = j;
                                num++;
                                newPoint.x += actPoint.x;
                                newPoint.y += actPoint.y;
                        } else if (start != -1) {
                                // Erase unnessecary points and add the new relative point.
                                lines[i].second.erase(lines[i].second.begin() + start,
                                                lines[i].second.begin() + j);
                                lines[i].second.insert(lines[i].second.begin() + start + 1,
                                                newPoint);
                                // Initialize again.
                                j = start + 1;
                                start = -1;
                                newPoint.x = 0;
                                newPoint.y = 0;
                        }
                        // Don't forgot to do the last minimization.
                        if (start != -1 && j == lines[i].second.size() - 1) {
                                lines[i].second.erase(lines[i].second.begin() + start,
                                                lines[i].second.begin() + j);
                                lines[i].second.insert(lines[i].second.begin() + start + 1,
                                                newPoint);
                        }
                }
        }
}

void GetLines::eraseNearestNeighbours(size_t maxDistance, size_t distance,
                vector<CvPoint2D32f>& absolutePoints) {
        // In this array (in)valid points are going to be stored. At the end every
        // point, who is not valid is going to be erased.
        size_t size = absolutePoints.size();
        bool validPoints[size];
        // Initialize with true.
        for (size_t i = 0; i < size; i++)
                validPoints[i] = true;

        for (size_t j = 0; j < absolutePoints.size(); j++) {
                // Points which are marked as erased are not going to be analysed.
                if (!validPoints[j])
                        continue;
                // Now eliminate neighbors with a radius of at least distance.
                for (size_t end = j + distance; end < absolutePoints.size(); end++) {
                        if (!validPoints[end])
                                continue;
                        CvPoint2D32f diff;
                        diff.x = (absolutePoints[end].x - absolutePoints[j].x);
                        diff.y = (absolutePoints[end].y - absolutePoints[j].y);
                        float distanceX = sqrt(diff.x * diff.x + diff.y * diff.y);
                        if (distanceX <= maxDistance)
                                validPoints[end] = false;
                }

                for (size_t begin = 0;
                                begin < j - distance && begin < absolutePoints.size();
                                begin++) {
                        if (!validPoints[begin])
                                continue;
                        CvPoint2D32f diff;
                        diff.x = (absolutePoints[begin].x - absolutePoints[j].x);
                        diff.y = (absolutePoints[begin].y - absolutePoints[j].y);
                        float distanceX = sqrt(diff.x * diff.x + diff.y * diff.y);
                        if (distanceX <= maxDistance)
                                validPoints[begin] = false;
                }
        }

        // Temporary vector to avoid position problems when "deleting".
        vector<CvPoint2D32f> tmp = absolutePoints;
        absolutePoints.clear();
        for (size_t i = 0; i < tmp.size(); i++)
                if (validPoints[i])
                        absolutePoints.push_back(tmp[i]);

        // Now look for every point if there are points near to him. If not erase him.
        for (size_t i = 0; i < absolutePoints.size() && absolutePoints.size() > 10;
                        i++) {
                bool neighbourFound = false;
                for (size_t j = 0; j < absolutePoints.size(); j++) {
                        if (j == i)
                                continue;
                        CvPoint2D32f diff;
                        diff.x = (absolutePoints[i].x - absolutePoints[j].x);
                        diff.y = (absolutePoints[i].y - absolutePoints[j].y);
                        float distance = sqrt(diff.x * diff.x + diff.y * diff.y);
                        if (distance <= maxDistance * 10) {
                                neighbourFound = true;
                                break;
                        }
                }
                if (!neighbourFound)
                        absolutePoints.erase(absolutePoints.begin() + i);
        }
}

void GetLines::eraseDoubleLines(size_t maxDistance) {
        for (size_t i = 0; i < lines.size(); i++) {
                // Make all points absolute.
                vector<CvPoint2D32f> absolutePoints;
                CvPoint2D32f absolute;
                absolute.x = lines[i].first.x;
                absolute.y = lines[i].first.y;
                absolutePoints.push_back(absolute);
                int distance = 0;
                for (size_t j = 0; j < lines[i].second.size(); j++) {
                        absolute.x += lines[i].second[j].x;
                        absolute.y += lines[i].second[j].y;
                        absolutePoints.push_back(absolute);
                        CvPoint2D32f diff;
                        diff.x = absolutePoints[j + 1].x - absolutePoints[j].x;
                        diff.y = absolutePoints[j + 1].y - absolutePoints[j].y;
                        distance += sqrt(diff.x * diff.x + diff.y * diff.y);
                }
                // Erase double line.
                eraseNearestNeighbours(maxDistance, params.minDistanceWithinVector,
                                absolutePoints);

                // Compute the line length.
                lines[i].second.clear();
                lines[i].first = absolutePoints[0];
                float lineLength = 0;
                for (size_t j = 1; j < absolutePoints.size(); j++) {
                        CvPoint2D32f newRelPoint;
                        newRelPoint.x = absolutePoints[j].x - absolutePoints[j - 1].x;
                        newRelPoint.y = absolutePoints[j].y - absolutePoints[j - 1].y;
                        float length = sqrt(
                                        newRelPoint.x * newRelPoint.x
                                                        + newRelPoint.y * newRelPoint.y);
                        lineLength += length;
                }

                // These lines are going to be splitted because of a too big distance. Store their
                // indices to look, if there is a shorter distance and connect them.
                vector<int> linesToConnect;

                // Make lines relative again, push them into the lines vector and erase too big sublines.
                for (size_t j = 1; j < absolutePoints.size(); j++) {
                        CvPoint2D32f newRelPoint;
                        newRelPoint.x = absolutePoints[j].x - absolutePoints[j - 1].x;
                        newRelPoint.y = absolutePoints[j].y - absolutePoints[j - 1].y;
                        // Erase to big sublines.
                        if (sqrt(
                                        newRelPoint.x * newRelPoint.x
                                                        + newRelPoint.y * newRelPoint.y)
                                        > (lineLength * params.splitFactor) / absolutePoints.size()
                                        && absolutePoints.size() > 5) {
                                // Mark it.
                                linesToConnect.push_back(i);
                                CvPoint2D32f absolute = absolutePoints[j];
                                vector<CvPoint2D32f> relative;
                                i++;
                                lines.insert(lines.begin() + i, make_pair(absolute, relative));
                                continue;
                        }
                        lines[i].second.push_back(newRelPoint);
                }

                // Now try to connect the splitted lines.
                for (size_t j = 0; j < linesToConnect.size(); j++) {
                        int position = linesToConnect[linesToConnect.size() - 1 - j];
                        vector<pair<CvPoint2D32f, vector<CvPoint2D32f> > > linesToConnectVec;
                        linesToConnectVec.push_back(lines[position]);
                        linesToConnectVec.push_back(lines[position + 1]);
                        vector<Lines> connectedLines = connectLines(maxDistance,
                                        linesToConnectVec);
                        // If a connection was possible.
                        if (linesToConnectVec.size() == 1) {
                                lines[position] = linesToConnectVec[0];
                                lines.erase(lines.begin() + position + 1);
                                //j++;
                        }
                        // If no connection was possible.
                        // Unfortunately not working. Too many lines, which don't belong there.
                        /*else
                         {
                         CvPoint2D32f diff;
                         diff.x = connectedLines[1].start.x - connectedLines[0].end.x;
                         diff.y = connectedLines[1].start.y - connectedLines[0].end.y;
                         lines[position].second.push_back(diff);
                         for (size_t k = 0; k < connectedLines[1].relative.size(); k++)
                         lines[position].second.push_back(connectedLines[1].relative[k]);
                         lines.erase(lines.begin() + position + 1);
                         }*/

                }
        }

        // Erase very small lines. Probably better to do this depending on the line
        // length instead of its size.
        for (int i = lines.size() - 1; i >= 0; i--)
                if (lines[i].second.size() <= params.minLineSize)
                        lines.erase(lines.begin() + i);
}

vector<GetLines::Lines> GetLines::connectLines(size_t maxDistance,
                vector<pair<CvPoint2D32f, vector<CvPoint2D32f> > >& linesToConnect) {
        // Initialize Lines vector for analysing more simple.
        vector<Lines> connectedLines;
        for (size_t i = 0; i < linesToConnect.size(); i++) {
                Lines act;
                act.id = i;
                act.start = linesToConnect[i].first;
                act.end = linesToConnect[i].first;
                for (size_t j = 0; j < linesToConnect[i].second.size(); j++) {
                        act.relative.push_back(linesToConnect[i].second[j]);
                        act.end.x += linesToConnect[i].second[j].x;
                        act.end.y += linesToConnect[i].second[j].y;
                }
                connectedLines.push_back(act);
        }

        // Append lines with less distance to each other
        for (size_t i = 0; i < connectedLines.size(); i++)
                for (size_t j = 0; j < connectedLines.size(); j++) {
                        if (connectedLines[i].id == connectedLines[j].id)
                                continue;
                        CvPoint2D32f diff;

                        // erase those lines with near starting / endpoint
                        diff.x = (connectedLines[i].start.x - connectedLines[j].end.x);
                        diff.y = (connectedLines[i].start.y - connectedLines[j].end.y);
                        float distance = sqrt(diff.x * diff.x + diff.y * diff.y);
                        if (distance <= maxDistance) {
                                connectedLines[j].relative.push_back(diff);
                                for (size_t k = 0; k < connectedLines[i].relative.size(); k++)
                                        connectedLines[j].relative.push_back(
                                                        connectedLines[i].relative[k]);
                                connectedLines[j].end = connectedLines[i].end;
                                connectedLines.erase(connectedLines.begin() + i);
                                i = 0;
                                break;
                        }

                        // erase those lines with near starting points
                        diff.x = (connectedLines[i].start.x - connectedLines[j].start.x);
                        diff.y = (connectedLines[i].start.y - connectedLines[j].start.y);
                        distance = sqrt(diff.x * diff.x + diff.y * diff.y);
                        if (distance <= maxDistance) {
                                // Invert connectedLines[j]:
                                // end == start, start == end, negate relatives
                                Lines tmp;
                                tmp.start = connectedLines[j].end;
                                tmp.end = connectedLines[j].start;
                                for (size_t k = 0; k < connectedLines[j].relative.size(); k++) {
                                        CvPoint2D32f newRelPoint =
                                                        connectedLines[j].relative[connectedLines[j].relative.size()
                                                                        - 1 - k];
                                        newRelPoint.x = -newRelPoint.x;
                                        newRelPoint.y = -newRelPoint.y;
                                        tmp.relative.push_back(newRelPoint);
                                }
                                connectedLines[j] = tmp;
                                connectedLines[j].relative.push_back(diff);
                                for (size_t k = 0; k < connectedLines[i].relative.size(); k++)
                                        connectedLines[j].relative.push_back(
                                                        connectedLines[i].relative[k]);
                                connectedLines[j].end = connectedLines[i].end;
                                connectedLines.erase(connectedLines.begin() + i);
                                i = 0;
                                break;
                        }

                        // erase those lines with near end points
                        diff.x = (connectedLines[i].end.x - connectedLines[j].end.x);
                        diff.y = (connectedLines[i].end.y - connectedLines[j].end.y);
                        distance = sqrt(diff.x * diff.x + diff.y * diff.y);
                        if (distance <= maxDistance) {
                                // Invert connectedLines[i]:
                                // end == start, start == end, negate relatives
                                Lines tmp;
                                tmp.start = connectedLines[i].end;
                                tmp.end = connectedLines[i].start;
                                for (size_t k = 0; k < connectedLines[i].relative.size(); k++) {
                                        CvPoint2D32f newRelPoint =
                                                        connectedLines[i].relative[connectedLines[i].relative.size()
                                                                        - 1 - k];
                                        newRelPoint.x = -newRelPoint.x;
                                        newRelPoint.y = -newRelPoint.y;
                                        tmp.relative.push_back(newRelPoint);
                                }
                                connectedLines[i] = tmp;
                                connectedLines[j].relative.push_back(diff);
                                for (size_t k = 0; k < connectedLines[i].relative.size(); k++)
                                        connectedLines[j].relative.push_back(
                                                        connectedLines[i].relative[k]);
                                connectedLines[j].end = connectedLines[i].end;
                                connectedLines.erase(connectedLines.begin() + i);
                                i = 0;
                                break;
                        }
                }

        // Clear the vector and push in the new lines.
        linesToConnect.clear();
        for (size_t i = 0; i < connectedLines.size(); i++) {
                linesToConnect.push_back(
                                make_pair(connectedLines[i].start, connectedLines[i].relative));
        }
        return connectedLines;
}

void GetLines::readInFile(string& image, vector<string>* output) {
        // Look which format image has.
        size_t formatPos = image.find_last_of(".");
        string format = image.substr(formatPos + 1);
        image_name = image.substr(0, formatPos);

        // If it is not bmp, just convert it.
        // First convert it to pbm, since "convert" has problems with pngs directly
        // converting to bmp.
        if (format != "bmp") {
                string command = "convert " + image + " " + image_name + ".pbm";
                if (system(command.c_str())) {
                        cout << "Could not convert to pbm." << endl;
                        exit(1);
                }
                command = "convert " + image_name + ".pbm " + image_name + ".bmp";
                if (system(command.c_str())) {
                        cout << "Could not convert to bmp." << endl;
                        exit(1);
                }
        }

        // Now create the hpgl file.
        string pltfile = image_name + ".plt";
        string path = ros::package::getPath("portrait_painter") + "/bin/";
        string invert = "";
        if (params.invert)
                invert = "-i ";
        string command = path + "potrace " + invert + "-a 1000 -n -b hpgl -u 1 -t "
                        + boost::lexical_cast<string>(params.turdSize) + " -o " + image_name
                        + ".plt " + image_name + ".bmp";
        if (system(command.c_str())) {
                cout << "Could not execute potrace without an error." << endl;
                exit(1);
        }

        // Read in the file.
        ifstream infile(pltfile.c_str());
        if (!infile.is_open()) {
                cout << "Error: " << pltfile << " could not be opened." << endl;
                exit(1);
        }
        while (!infile.eof()) {
                string buff;
                getline(infile, buff, ';');
                output->push_back(buff);
        }
        return;
}

vector<pair<CvPoint2D32f, vector<CvPoint2D32f> > > GetLines::scaleTo(
                size_t size, bool preserveRatio) {
        if (lines.size() == 0) {
                cout
                                << "There are no lines stored. Probably you forgot to compute them. Use getLines(string& image) first."
                                << endl;
                exit(1);
        }
        // Initialize
        size_t size_x = _size, size_y = _size;
        size_t offset_x = 0, offset_y = 0;
        if (_size == -1) {
                size_x = src.cols;
                size_y = src.rows;

                // The robot is working with a quadratic szene, ... so make it quadratic.
                if (src.cols >= src.rows && preserveRatio) {
                        _size = src.cols;
                        size_y = src.cols;
                        offset_y = src.cols - src.rows;
                } else if (src.rows > src.cols && preserveRatio) {
                        offset_x = src.rows - src.cols;
                        _size = src.rows;
                        size_x = src.rows;
                }
        }

        // Now compute the new points.
        for (size_t i = 0; i < lines.size(); i++) {
                lines[i].first.x += floor(offset_x / 2.0);
                lines[i].first.y += floor(offset_y / 2.0);
                lines[i].first.x *= (size / (float) size_x);
                lines[i].first.y *= (size / (float) size_y);
                if (lines[i].first.x > size || lines[i].first.y > size)
                        cout << "Too high absolute value: " << lines[i].first.x << " "
                                        << lines[i].first.y << endl;
                for (size_t j = 0; j < lines[i].second.size(); j++) {
                        lines[i].second[j].x *= (size / (float) size_x);
                        lines[i].second[j].y *= (size / (float) size_y);
                }
        }
        _size = size;
        return lines;
}

void GetLines::drawLines() {
        if (lines.size() == 0) {
                cout
                                << "There are no lines stored. Probably you forgot to compute them. Use getLines(string& image) first."
                                << endl;
                exit(1);
        } else if (_size >= 0 && _size < 30) {
                cout
                                << "Your image has a size of "
                                << _size
                                << " pixels. Actually that's too small for OpenCV to draw the lines accurately. Use drawLines() after scaleTo(size_t size, bool preserveRatio)."
                                << endl;
                exit(1);
        }

        IplImage* out;
        if (_size == -1)
                out = cvCreateImage(cvSize(src.cols, src.rows), IPL_DEPTH_8U, 3);
        else
                out = cvCreateImage(cvSize(_size, _size), IPL_DEPTH_8U, 3);
        // Draw image by converting all points to absolute points.
        for (size_t i = 0; i < lines.size(); i++) {
                CvPoint2D32f absolute, absoluteOld;
                absolute.x = lines[i].first.x;
                absolute.y = lines[i].first.y;
                std::cerr << "Absolute Coordinates:" << absolute.x << " " << absolute.y
                                << std::endl;
                std::cerr << "Out Dimensions:" << out->width << " " << out->height
                                << std::endl;
                assert(absolute.x >= 0 && absolute.x < out->width);
                assert(absolute.y >= 0 && absolute.y < out->height);
                absoluteOld = absolute;
                // Mark starting point.
                //cvCircle (out, cvPointFrom32f(absoluteOld), 2, CV_RGB(0, 255, 255), 1);
                // Draw lines.
                for (size_t j = 0; j < lines[i].second.size(); j++) {
                        absoluteOld = absolute;
                        assert(absolute.x >= 0 && absolute.x < out->width);
                        assert(absolute.y >= 0 && absolute.y < out->height);
                        CvPoint2D32f rel = lines[i].second[j];
                        absolute.x += rel.x;
                        absolute.y += rel.y;
                        cvLine(out, cvPointFrom32f(absoluteOld), cvPointFrom32f(absolute),
                                        CV_RGB(255,255,0), 1);
                }
                // Mark end point.
                //cvCircle(out, cvPointFrom32f(absolute), 3, CV_RGB(255,0,0), 1);
        }
        cvSaveImage((image_name + "_lines.bmp").c_str(), out);
}

void GetLines::drawPR2(float percentualHeightOfImage) {
        if (percentualHeightOfImage < 0 || percentualHeightOfImage > 1) {
                cout << "Percent not expected as \"k \%\", but as \"k/100\"." << endl;
                exit(1);
        }

        // Initialize.
        size_t heightOfImage = _size, widthOfImage = _size;
        if (_size == -1) {
                heightOfImage = src.rows;
                widthOfImage = src.cols;
        }

        float height = heightOfImage * percentualHeightOfImage;
        float widthPerLetter = height / 1.5;
        float offsetBetweenLetters = widthPerLetter / 1.5;
        float diagonal = height / 20.0;
        float position_y = heightOfImage - height / 4.0;
        float position_x = widthOfImage - 4 * widthPerLetter
                        - 2 * offsetBetweenLetters;
        pair<CvPoint2D32f, vector<CvPoint2D32f> > letter_P, letter_R, letter_2;

        // Insert lines.
        // Letter P.
        letter_P.first = cvPoint2D32f(position_x, position_y);
        letter_P.second.push_back(cvPoint2D32f(0, -height));
        letter_P.second.push_back(cvPoint2D32f(widthPerLetter - 2 * diagonal, 0));
        letter_P.second.push_back(cvPoint2D32f(2 * diagonal, 2 * diagonal));
        letter_P.second.push_back(cvPoint2D32f(0, height / 3.0));
        int pos = letter_P.second.size() - 1;
        letter_P.second.push_back(cvPoint2D32f(-2 * diagonal, 2 * diagonal));
        letter_P.second.push_back(
                        cvPoint2D32f(-(widthPerLetter - 2 * diagonal), 0));

        // Letter R.
        letter_R.first = cvPoint2D32f(
                        position_x + widthPerLetter + offsetBetweenLetters, position_y);
        letter_R.second = letter_P.second;
        letter_R.second[pos] = cvPoint2D32f(0, height / 4.0);
        letter_R.second.push_back(
                        cvPoint2D32f(widthPerLetter,
                                        height - letter_R.second[pos].y - 4 * diagonal));

        // Letter 2.
        diagonal = widthPerLetter / 25.0;
        letter_2.first = cvPoint2D32f(
                        position_x + widthPerLetter * 2 + 2 * offsetBetweenLetters,
                        position_y - height + 15 * diagonal);
        letter_2.second.push_back(cvPoint2D32f(0, -5 * diagonal));
        letter_2.second.push_back(cvPoint2D32f(1 * diagonal, -4 * diagonal));
        letter_2.second.push_back(cvPoint2D32f(2 * diagonal, -3 * diagonal));
        letter_2.second.push_back(cvPoint2D32f(3 * diagonal, -2 * diagonal));
        letter_2.second.push_back(cvPoint2D32f(4 * diagonal, -1 * diagonal));
        letter_2.second.push_back(cvPoint2D32f(5 * diagonal, 0));
        letter_2.second.push_back(cvPoint2D32f(4 * diagonal, 1 * diagonal));
        letter_2.second.push_back(cvPoint2D32f(3 * diagonal, 2 * diagonal));
        letter_2.second.push_back(cvPoint2D32f(2 * diagonal, 3 * diagonal));
        letter_2.second.push_back(cvPoint2D32f(1 * diagonal, 4 * diagonal));
        letter_2.second.push_back(cvPoint2D32f(0, 5 * diagonal));
        letter_2.second.push_back(cvPoint2D32f(-1 * diagonal, 4 * diagonal));
        letter_2.second.push_back(
                        cvPoint2D32f(-widthPerLetter + diagonal,
                                        height - 19 * diagonal - height / 10.0));
        letter_2.second.push_back(cvPoint2D32f(0, height / 10.0));
        letter_2.second.push_back(cvPoint2D32f(widthPerLetter, 0));

        lines.push_back(letter_P);
        lines.push_back(letter_R);
        lines.push_back(letter_2);
        // Set more points, so PR2 is really going to draw the whole letters.
        // Little improvement, but not much.
        for (size_t i = lines.size() - 4; i < lines.size(); i++) {
                for (size_t j = 0; j < lines[i].second.size(); j++) {
                        // Split each line from point to point into numOfSplits parts.
                        CvPoint2D32f divided;
                        size_t numOfSplits = 3;
                        divided = cvPoint2D32f(lines[i].second[j].x / (float) numOfSplits,
                                        lines[i].second[j].y / (float) numOfSplits);
                        lines[i].second[j] = divided;
                        for (size_t k = 0; k < numOfSplits - 1; k++)
                                lines[i].second.insert(lines[i].second.begin() + j, divided);
                        j += numOfSplits - 1;
                }
        }
}

void GetLines::setPotraceParams(size_t turdSize, bool invert) {
        params.turdSize = turdSize;
        params.invert = invert;
}

void GetLines::setErasingParams(size_t maxDistanceBetweenPoints,
                size_t minDistanceWithinVector, float splitFactor, size_t minLineSize) {
        params.maxDistanceBetweenPoints = maxDistanceBetweenPoints;
        params.minDistanceWithinVector = minDistanceWithinVector;
        params.splitFactor = splitFactor;
        params.minLineSize = minLineSize;
}

void GetLines::setConnectingParams(size_t maxDistanceBetweenLines) {
        params.maxDistanceBetweenLines = maxDistanceBetweenLines;
}

void GetLines::setMinimizeLinesParams(size_t maxDistance, size_t threshold) {
        params.maxDistance = maxDistance;
        params.threshold = threshold;
}