mirror of
https://github.com/markqvist/OpenModem.git
synced 2025-05-06 08:25:16 -04:00
Working
This commit is contained in:
Mark Qvist
commit
c898b090dd
1049 changed files with 288572 additions and 0 deletions
404
bertos/gfx/fillpoly.cpp
Normal file
404
bertos/gfx/fillpoly.cpp
Normal file
|
|
@ -0,0 +1,404 @@
|
|||
/**
|
||||
* \file
|
||||
* <!--
|
||||
* This file is part of BeRTOS.
|
||||
*
|
||||
* Bertos is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* As a special exception, you may use this file as part of a free software
|
||||
* library without restriction. Specifically, if other files instantiate
|
||||
* templates or use macros or inline functions from this file, or you compile
|
||||
* this file and link it with other files to produce an executable, this
|
||||
* file does not by itself cause the resulting executable to be covered by
|
||||
* the GNU General Public License. This exception does not however
|
||||
* invalidate any other reasons why the executable file might be covered by
|
||||
* the GNU General Public License.
|
||||
*
|
||||
* Copyright 2005 Develer S.r.l. (http://www.develer.com/)
|
||||
*
|
||||
* -->
|
||||
*
|
||||
* \author Massimiliano Corsini <chad@develer.com>
|
||||
*
|
||||
*
|
||||
* \brief Low-level drawing routines.
|
||||
*
|
||||
* This file contains the implementation of the low-level drawing routines
|
||||
* to draw fill rectangle, fill triangle and so on.
|
||||
*
|
||||
*/
|
||||
|
||||
/*#*
|
||||
*#* $Log$
|
||||
*#* Revision 1.1 2006/07/19 13:00:01 bernie
|
||||
*#* Import into DevLib.
|
||||
*#*
|
||||
*#* Revision 1.10 2005/10/15 15:03:43 rasky
|
||||
*#* Remove per-pixel clipping from line().
|
||||
*#* Use clipLine() also for a-scope.
|
||||
*#*
|
||||
*#* Revision 1.9 2005/10/14 15:21:32 eldes
|
||||
*#* Implement the cohen-sutherland clipping on the buffer
|
||||
*#*
|
||||
*#* Revision 1.8 2005/09/27 13:28:10 rasky
|
||||
*#* Add clipping capabilities to line()
|
||||
*#* Fix off-by-one computation of rectangles of drawing.
|
||||
*#*
|
||||
*#* Revision 1.7 2005/09/27 10:41:35 rasky
|
||||
*#* Import line-drawing routine from Devlib
|
||||
*#*
|
||||
*#* Revision 1.6 2005/09/19 16:36:05 chad
|
||||
*#* Fix doxygen autobrief
|
||||
*#*
|
||||
*#* Revision 1.5 2005/07/06 12:51:47 chad
|
||||
*#* Make the fillRectangle() independent of the order of the points of the rectangle
|
||||
*#*
|
||||
*#* Revision 1.4 2005/06/17 15:06:36 chad
|
||||
*#* Remove conversion warning
|
||||
*#*
|
||||
*#* Revision 1.3 2005/06/17 15:04:47 chad
|
||||
*#* Add line clipping capability
|
||||
*#*
|
||||
*#* Revision 1.2 2005/06/15 14:04:43 chad
|
||||
*#* Add line routine
|
||||
*#*
|
||||
*#* Revision 1.1 2005/06/15 13:34:34 chad
|
||||
*#* Low-level drawing routines
|
||||
*#*
|
||||
*#*/
|
||||
|
||||
// Qt-specific headers
|
||||
#include <qpoint.h>
|
||||
|
||||
|
||||
/**
|
||||
* Low-level routine to draw a line.
|
||||
*
|
||||
* This routine is based on the Bresenham Line-Drawing Algorithm.
|
||||
*
|
||||
* The \a stride represents the width of the image buffer.
|
||||
* (\a x1, \a y1) are the coordinates of the starting point.
|
||||
* (\a x2, \a y2) are the coordinates of the ending point.
|
||||
*
|
||||
* The line has no anti-alias, and clipping is not performed. The line
|
||||
* must be fully contained in the buffer (use clipLine() if you need
|
||||
* to clip it).
|
||||
*/
|
||||
void line(unsigned char *buf,
|
||||
unsigned long bufw, unsigned long bufh, unsigned long stride,
|
||||
int x1, int y1, int x2, int y2, unsigned char color)
|
||||
{
|
||||
int x, y, e, len, adx, ady, signx, signy;
|
||||
|
||||
if (x2 > x1)
|
||||
{
|
||||
/* left to right */
|
||||
signx = +1;
|
||||
adx = x2 - x1;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* right to left */
|
||||
signx = -1;
|
||||
adx = x1 - x2;
|
||||
}
|
||||
|
||||
if (y2 > y1)
|
||||
{
|
||||
/* top to bottom */
|
||||
signy = +1;
|
||||
ady = y2 - y1;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* bottom to top */
|
||||
signy = -1;
|
||||
ady = y1 - y2;
|
||||
}
|
||||
|
||||
x = x1;
|
||||
y = y1;
|
||||
|
||||
if (adx > ady)
|
||||
{
|
||||
/* X-major line (octants 1/4/5/8) */
|
||||
len = adx;
|
||||
e = -adx;
|
||||
while (len--)
|
||||
{
|
||||
/* Sanity check */
|
||||
assert(y >= 0 && y < static_cast<int>(bufh) &&
|
||||
x >= 0 && x < static_cast<int>(bufw));
|
||||
buf[y * stride + x] = color;
|
||||
x += signx;
|
||||
e += ady;
|
||||
if (e >= 0)
|
||||
{
|
||||
y += signy;
|
||||
e -= adx;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Y-major line (octants 2/3/6/7) */
|
||||
len = ady;
|
||||
e = -ady;
|
||||
while (len--)
|
||||
{
|
||||
/* Sanity check */
|
||||
assert(y >= 0 && y < static_cast<int>(bufh) &&
|
||||
x >= 0 && x < static_cast<int>(bufw));
|
||||
buf[y * stride + x] = color;
|
||||
y += signy;
|
||||
e += adx;
|
||||
if (e >= 0)
|
||||
{
|
||||
x += signx;
|
||||
e -= ady;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Helper routine for clipLine().
|
||||
static int region(int x, int y, int w, int h)
|
||||
{
|
||||
int code = 0;
|
||||
|
||||
if (y >= h)
|
||||
code |= 1; // top
|
||||
else if (y < 0)
|
||||
code |= 2; // bottom
|
||||
|
||||
if (x >= w)
|
||||
code |= 4; // right
|
||||
else if (x < 0)
|
||||
code |= 8; // left
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
/**
|
||||
* Low-level routine to draw a line, clipped to the buffer extents.
|
||||
*
|
||||
* This routine executes the clipping, and then invokes line().
|
||||
* Parameters are the same of line(). The clipping is performed
|
||||
* using the Cohen-Sutherland algorithm, which is very fast.
|
||||
*/
|
||||
void clipLine(unsigned char *buf,
|
||||
unsigned long w, unsigned long h, unsigned long stride,
|
||||
int x1, int y1, int x2, int y2, unsigned char color)
|
||||
{
|
||||
int code1 = region(x1, y1, w, h);
|
||||
int code2 = region(x2, y2, w, h);
|
||||
|
||||
// Loop while there is at least one point outside
|
||||
while (code1 | code2)
|
||||
{
|
||||
// Check for line totally outside
|
||||
if (code1 & code2)
|
||||
return;
|
||||
|
||||
int c = code1 ? code1 : code2;
|
||||
int x, y;
|
||||
|
||||
if (c & 1) // top
|
||||
{
|
||||
x = x1 + (x2 - x1) * (h - y1) / (y2 - y1);
|
||||
y = h - 1;
|
||||
}
|
||||
else if (c & 2) //bottom
|
||||
{
|
||||
x = x1 + (x2 - x1) * -y1 / (y2 - y1);
|
||||
y = 0;
|
||||
}
|
||||
else if (c & 4) //right
|
||||
{
|
||||
y = y1 + (y2 - y1) * (w - x1) / (x2 - x1);
|
||||
x = w - 1;
|
||||
}
|
||||
else //left
|
||||
{
|
||||
y = y1 + (y2 - y1) * -x1 / (x2 - x1);
|
||||
x = 0;
|
||||
}
|
||||
|
||||
if (c == code1) // first endpoint was clipped
|
||||
{
|
||||
x1 = x; y1 = y;
|
||||
code1 = region(x1, y1, w, h);
|
||||
}
|
||||
else //second endpoint was clipped
|
||||
{
|
||||
x2 = x; y2 = y;
|
||||
code2 = region(x2, y2, w, h);
|
||||
}
|
||||
}
|
||||
|
||||
line(buf, w, h, stride, x1, y1, x2, y2, color);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Low-level routine to draw a filled rectangle.
|
||||
*
|
||||
* The triangle is filled with the given color.
|
||||
*
|
||||
* The \a stride represents the width of the image buffer.
|
||||
* The points \a p1 and \a p2 are two opposite corners of the
|
||||
* rectangle.
|
||||
*/
|
||||
void fillRectangle(unsigned char *buf, unsigned long stride,
|
||||
QPoint p1, QPoint p2, unsigned char color)
|
||||
{
|
||||
QPoint ul; // upper-left corner
|
||||
QPoint lr; // lower-right corner
|
||||
|
||||
if (p2.x() > p1.x())
|
||||
{
|
||||
ul.setX(p1.x());
|
||||
lr.setX(p2.x());
|
||||
}
|
||||
else
|
||||
{
|
||||
ul.setX(p2.x());
|
||||
lr.setX(p1.x());
|
||||
}
|
||||
|
||||
if (p2.y() > p1.y())
|
||||
{
|
||||
ul.setY(p1.y());
|
||||
lr.setY(p2.y());
|
||||
}
|
||||
else
|
||||
{
|
||||
ul.setY(p2.y());
|
||||
lr.setY(p1.y());
|
||||
}
|
||||
|
||||
int width = lr.x() - ul.x();
|
||||
unsigned long offset = ul.x() + ul.y()*stride;
|
||||
|
||||
for (int h = ul.y(); h < lr.y(); h++)
|
||||
{
|
||||
memset(buf+offset, color, width);
|
||||
offset += stride;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Low-level routines to draw a filled triangle.
|
||||
*
|
||||
* The triangle is filled with the given \a color.
|
||||
* The \a stride represents the width of the image buffer (\a buf).
|
||||
*
|
||||
* The routine use fixed-point arithmetic.
|
||||
*/
|
||||
void fillTriangle(unsigned char* buf, unsigned long stride,
|
||||
QPoint v1, QPoint v2, QPoint v3, unsigned char color)
|
||||
{
|
||||
int altezza[3];
|
||||
|
||||
// Sort by vertical coordinate
|
||||
if (v1.y() > v2.y())
|
||||
std::swap(v1, v2);
|
||||
if (v1.y() > v3.y())
|
||||
std::swap(v1, v3);
|
||||
if (v2.y() > v3.y())
|
||||
std::swap(v2, v3);
|
||||
|
||||
altezza[0] = v3.y() - v1.y();
|
||||
if (!altezza[0])
|
||||
return;
|
||||
|
||||
int sezioni = 2;
|
||||
int sezione = 1;
|
||||
|
||||
buf += v1.y() * stride;
|
||||
|
||||
altezza[1] = v2.y() - v1.y();
|
||||
altezza[2] = v3.y() - v2.y();
|
||||
|
||||
int sinistra = v1.x();
|
||||
int destra = sinistra;
|
||||
|
||||
if (v1.y() == v2.y())
|
||||
{
|
||||
if (v1.x() < v2.x())
|
||||
destra = v2.x();
|
||||
else
|
||||
sinistra = v2.x();
|
||||
}
|
||||
|
||||
sinistra <<= 16;
|
||||
destra <<= 16;
|
||||
|
||||
int stmp1, stmp2, stmp3;
|
||||
|
||||
stmp1 = (altezza[1] << 16) / altezza[0];
|
||||
int lunghezza = stmp1 * (v3.x() - v1.x()) + ((v1.x() - v2.x()) << 16);
|
||||
|
||||
if (!lunghezza )
|
||||
return;
|
||||
|
||||
int delta_sinistra[2];
|
||||
int delta_destra[2];
|
||||
|
||||
stmp1 = ((v3.x() - v1.x()) << 16) / altezza[0];
|
||||
|
||||
if (altezza[1])
|
||||
stmp2 = ((v2.x() - v1.x()) << 16) / altezza[1];
|
||||
if (altezza[2])
|
||||
stmp3 = ((v3.x() - v2.x()) << 16) / altezza[2];
|
||||
|
||||
if (lunghezza < 0) // Il secondo vertice ~J a destra
|
||||
{
|
||||
delta_sinistra[0] = stmp1;
|
||||
delta_sinistra[1] = stmp1;
|
||||
delta_destra[0] = stmp2;
|
||||
delta_destra[1] = stmp3;
|
||||
}
|
||||
else // Il secondo vertice ~J a sinistra
|
||||
{
|
||||
delta_sinistra[0] = stmp2;
|
||||
delta_sinistra[1] = stmp3;
|
||||
delta_destra[0] = stmp1;
|
||||
delta_destra[1] = stmp1;
|
||||
}
|
||||
|
||||
int len2 = lunghezza;
|
||||
|
||||
do
|
||||
{
|
||||
while (altezza [sezione])
|
||||
{
|
||||
unsigned char* curpos = buf + ((sinistra )>> 16);
|
||||
lunghezza = ((destra ) >> 16) - ((sinistra ) >> 16);
|
||||
assert(lunghezza >= 0);
|
||||
if (lunghezza)
|
||||
memset(curpos, color, lunghezza);
|
||||
buf += stride;
|
||||
destra += delta_destra[sezione - 1];
|
||||
sinistra += delta_sinistra[sezione - 1];
|
||||
altezza[sezione]--;
|
||||
}
|
||||
if (len2 < 0)
|
||||
destra = v2.x() << 16;
|
||||
else
|
||||
sinistra = v2.x() << 16;
|
||||
sezione++;
|
||||
} while (--sezioni);
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue