/******************************Module*Header*******************************\
* Module Name: rgn2path.cxx *
* *
* Created: 14-Sep-1993 11:00:07 *
* Author: Kirk Olynyk [kirko] *
* *
* Copyright (c) 1993 Microsoft Corporation *
* *
* Discussion *
* *
* Input *
* *
* The input to the diagonalization routing is a rectangular *
* path whose vertices have integer endpoints. Moreover it *
* is required that the path always has the region on its *
* left and that successive lines are mutually orthogonal. *
* *
* All paths are in device 28.4 coordinates. (Since all of *
* the input coordinates are integers, the fractional part of all *
* coordinates is zero.) *
* *
* Output *
* *
* A path that contains the same pixels as the originl path. *
* *
* Filling Convention *
* *
* Any region bounded by two non-horizontal lines is closed *
* on the left and open on the right. If the region is bounded *
* by two horizontal lines, it is closed on the top and open on *
* bottom. *
* *
* Definition *
* *
* A CORNER is subsequence of two lines from the orignal axial path. *
* It is convenient to partition the set of corners into two classes; *
* HORIZONTAL-VERTIAL and VERTICAL-HORIZONTAL. *
* *
* A corner is "diagonalizable" the original two lines can be replaced *
* by a single diagonal line such that same pixels would be rendered *
* (using the filling convention defined above). *
* *
* *
* Nomenclature *
* *
* S ::= "SOUTH" ::= one pixel move in +y-direction *
* N ::= "NORTH" ::= one pixel move in -y-direction *
* E ::= "EAST" ::= one pixel move in +x direction *
* W ::= "WEST" ::= one pixel move in -x direction *
* *
* The set of diagonalizable corners are described by *
* the following regular expressions: *
* *
* DIAGONALIZABLE CORNERS *
* *
* S(E+|W+) a one pixel move in the +y-direction *
* followed by at least one pixel in any horizontal *
* direction *
* *
* S+W an arbitary number of pixels in the +y-direction *
* followed by a single pixel move in the *
* negative x-direction. *
* *
* EN+ a one pixel move in the positive x-direction *
* followed by at least one pixel move in the negative *
* x-direction *
* *
* (E+|W+)N at least one-pixel move in the horizontal followed *
* by a single pixel move in the negative *
* y-direction. *
* *
* Algorithm *
* *
* BEGIN *
* <For each corner in the orginal path> *
* BEGIN *
* <if the corner is diagonalizable> THEN *
* *
* <just draw a single diagonal line> *
* ELSE *
* <draw both legs of the original corner> *
* END *
* *
* <Go around the path once again, merging successive *
* identical moves into single lines> *
* END *
* *
* In the code, both of these steps are done in parallel *
* *
* Further Improvements *
* *
* The output path the I generate with this algorithm will contain only *
* points that were vertices of the original axial path. A larger of *
* regular expressions could be searched for if I were willing to *
* consider using new vertices for the output path. For example *
* the regular exprssios N+WN and S+ES describe two "chicane turns" that *
* can be diagonalized. The price to be paid is the a more complex *
* code path. *
* *
\**************************************************************************/
#include "precomp.hxx"
/******************************Public*Routine******************************\
* RTP_PATHMEMOBJ::bDiagonalize *
* *
* Produces a diagonalized path that is pixel equivalent. *
* *
* Assumptions *
* *
* 0. *this is the original path which will not be changed. *
* 1. All points on the path lie on integers *
* 2. All subpaths have the inside on the left *
* 3. All subpaths are closed *
* *
* History: *
* Mon 13-Sep-1993 15:53:50 by Kirk Olynyk [kirko] *
* Wrote it. *
\**************************************************************************/
BOOL RTP_PATHMEMOBJ::bDiagonalizePath(EPATHOBJ* pepoOut_)
{
pepoOut = pepoOut_;
bMoreToEnum = TRUE;
vEnumStart();
while (bFetchSubPath())
{
if (!bDiagonalizeSubPath())
{
return(FALSE);
}
}
return(TRUE);
}
/******************************Public*Routine******************************\
* RTP_PATHMEMOBJ::bFetchSubPath *
* *
* History: *
* Wed 15-Sep-1993 14:19:14 by Kirk Olynyk [kirko] *
* Wrote it. *
\**************************************************************************/
BOOL RTP_PATHMEMOBJ::bFetchSubPath()
{
BOOL bRet = FALSE;
if (bMoreToEnum) {
// first we whiz on by any empty subpaths
do {
bMoreToEnum = bEnum(&pd);
} while ((pd.count == 0) && (bMoreToEnum));
if (pd.count && (pd.flags & PD_BEGINSUBPATH) && pd.pptfx) {
// record the first point in the sub-path, we will need it later
// when dealing with the last corner in the path
ptfxFirst = *(pd.pptfx);
bRet = TRUE;
}
else
WARNING("RTP_PATHMEMOBJ::bFetchSubPath -- bad SubPath\n");
}
return(bRet);
}
/******************************Public*Routine******************************\
* RTP_PATHMEMOBJ::bWritePoint *
* *
* This routine takes as input a candidate point for writing. However *
* this routine is smart in that it analyzes the stream of candidate *
* points looking for consecutive sub-sets of points that all lie on the *
* same line. When such a case is recognized, then only the endpoints of *
* the interpolating line are actually added to the output path. *
* *
* I do not go to a great deal of trouble to determine if a candidate *
* point is on a line. All that I do is to see if the vector increment *
* to the new point is the same as the increment between prior points *
* in the input path. *
* *
* History: *
* Mon 13-Sep-1993 15:53:35 by Kirk Olynyk [kirko] *
* Wrote it. *
\**************************************************************************/
BOOL RTP_PATHMEMOBJ::bWritePoint()
{
POINTFIX ptfxNewAB;
BOOL bRet = TRUE;
int jA = j;
if (cPoints == 2)
{
ptfxNewAB.x = aptfx[jA].x - aptfxWrite[1].x;
ptfxNewAB.y = aptfx[jA].y - aptfxWrite[1].y;
if (ptfxNewAB.x != ptfxAB.x || ptfxNewAB.y != ptfxAB.y)
{
if (!(bRet = pepoOut->bPolyLineTo(aptfxWrite,1)))
{
WARNING((
"pepoOut->bPolyLineTo(aptfxWrite,1) failed when"
" called from RTP_PATHMEMOBJ::bWritePoint()\n"
));
}
else
{
aptfxWrite[0] = aptfxWrite[1];
ptfxAB = ptfxNewAB;
}
}
aptfxWrite[1] = aptfx[jA];
}
else if (cPoints == 0)
{
aptfxWrite[0] = aptfx[jA];
cPoints += 1;
}
else if (cPoints == 1)
{
aptfxWrite[1] = aptfx[jA];
ptfxAB.x = aptfxWrite[1].x - aptfxWrite[0].x;
ptfxAB.y = aptfxWrite[1].y - aptfxWrite[0].y;
cPoints += 1;
}
else
{
RIP("RTP_PATHMEMOBJ::bWritePoint -- bad cPoints\n");
bRet = FALSE;
}
return(bRet);
}
/******************************Public*Routine******************************\
* bFetchNextPoint ... in sub-path *
* *
* History: *
* Tue 14-Sep-1993 14:13:01 by Kirk Olynyk [kirko] *
* Wrote it. *
\**************************************************************************/
BOOL RTP_PATHMEMOBJ::bFetchNextPoint()
{
#define TRUE_BIT 1
#define DONE_BIT 2
int jold;
int flag = TRUE_BIT;
// advance the corner buffer along the path
// jold points to the stale member of the corner buffer. This is
// where we will store the new point in the path
jold = j;
j++;
if (j > 2)
{
j -= 3;
}
if (pd.count == 0)
{
// there are no points left in the current batch.
if (pd.flags & PD_ENDSUBPATH)
{
// If the PD_ENDSUBPATH flag was set, then we must add
// into this path the first point in the subpath. This
// is done so that later on, we can examine the last
// corner which, of course, contains the first point.
afl[jold] = 0;
aptfx[jold] = ptfxFirst; // close the path
pd.count -= 1;
flag = DONE_BIT | TRUE_BIT;
}
else
{
ASSERTGDI(
bMoreToEnum,
"RTP_PATHMEMOBJ::bFetchNextPoint() -- bMoreToEnum == FALSE\n"
);
// If you get to here, you have exhauseted the current batch of
// points, but there are more points left to be fetched for the
// current subpath. This means that we will have to make another
// call to bEnum()
bMoreToEnum = bEnum(&pd);
// At this point I check to make sure that the returned batch makes
// sense
if (!(pd.count > 0 && ((pd.flags & PD_BEGINSUBPATH) == 0) && pd.pptfx))
{
WARNING("RTP_PATHMEMOBJ::bFetchNextPoint -- bad pd\n");
flag = DONE_BIT;
}
}
}
if (!(flag & DONE_BIT))
{
if ((LONG) pd.count > 0)
{
aptfx[jold] = *(pd.pptfx);
if (pd.count == 1 && (pd.flags & PD_ENDSUBPATH))
{
afl[jold] = RTP_LAST_POINT;
}
else
{
afl[jold] = 0;
}
pd.pptfx += 1;
pd.count -= 1;
}
else
{
ASSERTGDI(
(LONG) pd.count > -3,
"RTP_PATHMEMOBJ::bFetchNextPoint -- pd.count < -2\n"
);
}
}
return((BOOL) flag & TRUE_BIT);
}
/******************************Public*Routine******************************\
* RTP_PATHMEMOBJ::bDiagonalizeSubPath *
* *
* History: *
* Tue 14-Sep-1993 12:47:49 by Kirk Olynyk [kirko] *
* Wrote it. *
\**************************************************************************/
#define ROTATE_BACKWARD(x,y,z) {int ttt = x; x = z; z = y; y = ttt;}
#define ROTATE_FORWARD(x,y,z) {int ttt = x; x = y; y = z; z = ttt;}
BOOL RTP_PATHMEMOBJ::bDiagonalizeSubPath()
{
FIX fxAB; // length of the first leg
FIX fxBC; // length of the second leg
int bH; // set to 1 if second leg is horizontal
int jA,jB,jC;
register BOOL bRet = TRUE; // if FALSE then return immediately
// otherwise keep processing.
cPoints = 0; // no points so far in the write buffer
j = 0; // set the start of the circular buffer
// Fill the circular buffer with the first three points of the
// path. The three member buffer, defines two successive lines, or
// one corner (the path is guaranteed to be composed of alternating
// lines along the x-axis and y-axis). I shall label the three vertices
// of the corner A,B, and C. The point A always resides at ax[j],
// point B resides at ax[iMod3[j+1]], and point C resides at
// ax[iMod3[j+2]] where j can have one of the values 0, 1, 2.
if (bRet = bFetchNextPoint() && bFetchNextPoint() && bFetchNextPoint())
{
ASSERTGDI(j == 0,"RTP_PATHMEMOBJ::bDiagonalizeSubPath() -- j != 0\n");
// bH ::= <is the second leg of the corner horizontal?>
//
// if the second leg of the corner is horizontal set bH=1 otherwise
// set bH=0. Calculate the length of the first leg of the corner
// and save it in fxAB. Note that I do not need to use the iMod3
// modulus operation since j==0.
if (aptfx[2].y == aptfx[1].y)
{
bH = 1;
fxAB = aptfx[1].y - aptfx[0].y;
}
else
{
bH = 0;
fxAB = aptfx[1].x - aptfx[0].x;
}
// Start a new subpath at the first point of the subpath.
bRet = pepoOut->bMoveTo(aptfx);
jA = 0;
jB = 1;
jC = 2;
}
while (bRet)
{
#if DBG
if (!(afl[jA] & RTP_LAST_POINT))
{
// Assert that the the legs of the corner are along
// the axes, and that the two legs are mutually
// orthogonal
ASSERTGDI(
aptfx[jC].x == aptfx[jB].x ||
aptfx[jC].y == aptfx[jB].y,
"Bad Path :: C-B is not axial\n"
);
ASSERTGDI(
aptfx[jA].x == aptfx[jB].x ||
aptfx[jA].y == aptfx[jB].y,
"Bad Path :: B-A is not axial\n"
);
ASSERTGDI(
(aptfx[jC].x - aptfx[jB].x) *
(aptfx[jB].x - aptfx[jA].x)
+
(aptfx[jC].y - aptfx[jB].y) *
(aptfx[jB].y - aptfx[jA].y)
== 0,
"Bad Path :: B-A is not orthogonal to C-B"
);
}
#endif
// If the first vertex of the corner is the last point in the
// original subpath then we terminate the processing. This point
// has either been recorded with PATHMEMOBJ::bMoveTo or
// PATHMEMOBJ::bPolyLineTo. All that remains is to close the
// subpath which is done outside the while loop
if (afl[jA] & RTP_LAST_POINT)
break;
// There are two paths through the following if-else clause
// They are for VERTICAL-HORIZONTAL and HORIZONTAL-VERTICAL
// corners respectively. These two clauses are identical
// except for the interchange of ".x" with ".y". It might be
// a good idea to have macros or subrouines for these sections
// in order that they be guranteed to be identical.
// Is the second leg of the corner horizontal?
if (bH)
{
// Yes, the second leg of the corner is horizontal
fxBC = aptfx[jC].x - aptfx[jB].x;
// Is the corner diagonalizable?
if ((fxAB > 0) && ((fxAB == FIX_ONE) || (fxBC == -FIX_ONE)))
{
// Yes, the corner is diagonalizable
//
// If the middle of the corner was the last point in the
// original path then the last point in the output path
// is the first point in the corner. This is because the
// last line in the output path is this diagonalized
// corner which will be produced automatically by the
// CloseFigure() call after this while-loop. Thus, in
// this case we would just break out of the loop.
if (afl[jB] & RTP_LAST_POINT)
break;
// The corner is diagonalizable. This means that we are no
// longer interested in the first two points of this corner.
// We therefore fetch the next two points of the path
// an place them in our circular corner-buffer.
if (!(bRet = bFetchNextPoint() && bFetchNextPoint()))
break;
// under modulo 3 arithmetic, incrementing by 2 is
// equivalent to decrementing by 1
ROTATE_BACKWARD(jA,jB,jC);
// fxAB is set to the length of the first leg of the new
// corner.
fxAB = aptfx[jB].y - aptfx[jA].y;
}
else
{
// No, the corner is not diagonalizable
//
// The corner cannot be diagonalized. Advance the corner
// to the next point in the original path. The orientation
// of the second leg of the corner will change. The length
// of the first leg of the new corner is set equal to the
// length of the second leg of the previous corner.
if (!(bRet = bFetchNextPoint()))
break;
ROTATE_FORWARD(jA,jB,jC);
bH ^= 1;
fxAB = fxBC;
}
}
else
{
// Diagonalize the HORIZONTAL->VERTICAL corner
fxBC = aptfx[jC].y - aptfx[jB].y;
if ((fxBC < 0) && ((fxAB == FIX_ONE) || (fxBC == -FIX_ONE)))
{
if (afl[jB] & RTP_LAST_POINT)
break;
if (!(bRet = bFetchNextPoint() && bFetchNextPoint()))
break;
ROTATE_BACKWARD(jA,jB,jC);
fxAB = aptfx[jB].x - aptfx[jA].x;
}
else
{
if (!(bRet = bFetchNextPoint()))
break;
ROTATE_FORWARD(jA,jB,jC);
bH ^= 1;
fxAB = fxBC;
}
}
if (!(bRet = bWritePoint()))
break;
}
if (bRet)
{
ASSERTGDI(cPoints == 2,"GDI Region To Path -- cPoints is not 2\n");
bRet = pepoOut->bPolyLineTo(aptfxWrite, 2) && pepoOut->bCloseFigure();
}
return(bRet);
}