Как сделать изображение на основе простого многоугольника?

Я хотел бы скопировать примерно прямоугольную область в прямоугольную область. Пример:

Обе области определяются их угловыми точками. Общее направление сохранено (нет переворачивания и т.д.).

Простое вращение исходного изображения не работает, так как противоположные стороны могут иметь разную длину.

До сих пор я не нашел возможности сделать это в чистом С# (за исключением ручного копирования пикселей), поэтому, полагаю, мне приходится прибегать к API Windows или к какой-то сторонней библиотеке?

Ответы

Ответ 1

Вообще говоря, то, что вы хотите сделать, это сопоставить координаты назначения с исходными координатами через функцию преобразования:

for (int y = 0; y < destHeight; y++) {
    for (x=0; x < destWidth; x++) {
        Color c = Transform(x, y, sourceImage, sourceTransform);
        SetPixel(destImage, x, y, c);
    }
}

Предположим, что sourceTransform - это объект, который инкапсулирует преобразование из исходного в dest-координаты (и наоборот).

Работа в dest-координатах упростит эту кривую в вашем ретрансформированном исходном изображении и позволит вам улучшить антиалиасы, поскольку вы можете сопоставить углы пикселя dest с исходным изображением и образцом внутри него и интерполировать/экстраполировать.

В вашем случае у вас будет набор линейных уравнений, которые выполняют отображение - в этом случае это называется четырехсторонним деформированием - см. этот предыдущий вопрос.

Ответ 2

Поскольку я не мог найти ответа, сам написал наивную реализацию. Он работает достаточно хорошо.

<сильные > Примеры

Я рисовал все примеры вручную в Paint, поэтому они не очень точны - этого было достаточно, чтобы проверить некоторые основы.

a) Незначительное вращение.

Источник:

source image

Результат:

resulting image

b) Различные стороны

Источник:

source 2

Результат:

result 2

c) Перспектива

Источник:

source 3

Результат:

result 3

код

(он специализируется на моем случае использования, но его легко адаптировать):

// _Corners are, well, the 4 corners in the source image
// _Px is an array of pixels extracted from the source image

public void Rescale ()
{
    RescaleImage (
        _Corners[0],
        _Corners[1],
        _Corners[3],
        _Corners[2],
        100,
        100);
}

private void RescaleImage (PointF TL, PointF TR, PointF LL, PointF LR, int sx, int sy)
{
    var bmpOut = new Bitmap (sx, sy);

    for (int x = 0; x < sx; x++) {
        for (int y = 0; y < sy; y++) {
            /*
             * relative position
             */
            double rx = (double) x / sx;
            double ry = (double) y / sy;

            /*
             * get top and bottom position
             */
            double topX = TL.X + rx * (TR.X - TL.X);
            double topY = TL.Y + rx * (TR.Y - TL.Y);
            double bottomX = LL.X + rx * (LR.X - LL.X);
            double bottomY = LL.Y + rx * (LR.Y - LL.Y);

            /*
             * select center between top and bottom point
             */
            double centerX = topX + ry * (bottomX - topX);
            double centerY = topY + ry * (bottomY - topY);

            /*
             * store result
             */
            var c = PolyColor (centerX, centerY);
            bmpOut.SetPixel (x, y, c);
        }
    }

    bmpOut.Save (_Path + "out5 rescale out.bmp");
}

private Color PolyColor (double x, double y)
{
    // get fractions
    double xf = x - (int) x;
    double yf = y - (int) y;

    // 4 colors - we're flipping sides so we can use the distance instead of inverting it later
    Color cTL = _Px[(int) y + 1, (int) x + 1];
    Color cTR = _Px[(int) y + 1, (int) x + 0];
    Color cLL = _Px[(int) y + 0, (int) x + 1];
    Color cLR = _Px[(int) y + 0, (int) x + 0];

    // 4 distances
    double dTL = Math.Sqrt (xf * xf + yf * yf);
    double dTR = Math.Sqrt ((1 - xf) * (1 - xf) + yf * yf);
    double dLL = Math.Sqrt (xf * xf + (1 - yf) * (1 - yf));
    double dLR = Math.Sqrt ((1 - xf) * (1 - xf) + (1 - yf) * (1 - yf));

    // 4 parts
    double factor = 1.0 / (dTL + dTR + dLL + dLR);
    dTL *= factor;
    dTR *= factor;
    dLL *= factor;
    dLR *= factor;

    // accumulate parts
    double r = dTL * cTL.R + dTR * cTR.R + dLL * cLL.R + dLR * cLR.R;
    double g = dTL * cTL.G + dTR * cTR.G + dLL * cLL.G + dLR * cLR.G;
    double b = dTL * cTL.B + dTR * cTR.B + dLL * cLL.B + dLR * cLR.B;

    Color c = Color.FromArgb ((int) (r + 0.5), (int) (g + 0.5), (int) (b + 0.5));

    return c;
}