![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bndscan.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / mandel|
Return to bndscan.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / mandel |
1.1 ! root 1: /******************************Module*Header*******************************\ ! 2: * Module Name: bndscan.c ! 3: * ! 4: * Contains the boundary scaning functions ! 5: * ! 6: * Created: 14-Apr-1992 10:59:52 ! 7: * Author: Petrus Wong ! 8: * ! 9: * Copyright (c) 1990 Microsoft Corporation ! 10: * ! 11: * Dependencies: ! 12: * ! 13: * none ! 14: * ! 15: \**************************************************************************/ ! 16: #include <windows.h> ! 17: #include <stdio.h> ! 18: #include "jtypes.h" ! 19: #include "bndscan.h" ! 20: ! 21: extern LONG lMul(LONG, LONG); ! 22: extern LONG lDiv(LONG, LONG); ! 23: ! 24: BOOL bBoundaryScanFix(PINFO); ! 25: LPPOINT pptTrace(LONG, LONG, PINFO, INT *, HDC); ! 26: DWORD dwGetNextBoundaryPoint(DWORD, POINT, LPPOINT, PINFO); ! 27: BOOL bEscape(POINT, LONG, LONG, LONG, LONG, int, RECT); ! 28: BOOL bDirToPt(DWORD, POINT, LPPOINT); ! 29: DWORD dwShift(DWORD, int, int); ! 30: ! 31: /******************************Public*Routine******************************\ ! 32: * ! 33: * bBoundaryScanFix ! 34: * ! 35: * Effects: Traces the outline of the mandelbrot set. Currently, ! 36: * 1. Uses the old method to set the color of each pixel ! 37: * 2. Remember the first pixel from top that doesn't escape ! 38: * st we can do boundary trace later. ! 39: * 3. When the whole set is done, do boundary trace. ! 40: * 4. Store the boundary points in an array. Then build a path. ! 41: * 5. Converts the path to region and then select the region as ! 42: * current clip region. ! 43: * ! 44: * Warnings: Only traces the first non-singular pixel island from top. ! 45: * ! 46: * History: ! 47: * 20-Feb-1992 -by- Petrus Wong ! 48: * Wrote it. ! 49: \**************************************************************************/ ! 50: ! 51: BOOL bBoundaryScanFix(PINFO pInfo) ! 52: { ! 53: DWORD dwTick1; ! 54: int m, n, o, p; ! 55: HDC hDC; ! 56: RECT rc; ! 57: LONG c1, c2; ! 58: LONG x0, y0; ! 59: int iIteration; ! 60: LPPOINT lpPt; ! 61: int iCount; ! 62: POINT Pt; ! 63: BOOL bFirstPtSet; ! 64: ! 65: pInfo->bMandel = TRUE; ! 66: pInfo->bDrawing = TRUE; ! 67: bFirstPtSet = FALSE; ! 68: iIteration = pInfo->iIteration; ! 69: hDC = GetDC(pInfo->hwnd); ! 70: GetClientRect(pInfo->hwnd, &rc); ! 71: ! 72: dwTick1 = GetTickCount(); ! 73: for (n=rc.bottom/2; n<=rc.bottom; n++) { ! 74: c2 = y0 = XformFix(n, rc.top, rc.bottom, pInfo->lyFrom, pInfo->lyTo); ! 75: ! 76: for (m=rc.left; m<=rc.right; m++) { ! 77: c1 = x0 = XformFix(m, rc.left, rc.right, pInfo->lxFrom, pInfo->lxTo); ! 78: Pt.x = m; ! 79: Pt.y = n; ! 80: if (bEscape(Pt, x0, y0, c1, c2, iIteration, rc)) { ! 81: //SetPixel(hDC, m, n, 0x000000ff); ! 82: } else { ! 83: ! 84: if (!bFirstPtSet) ! 85: { ! 86: o = m; ! 87: p = n; ! 88: bFirstPtSet = TRUE; ! 89: } ! 90: goto BOUNDTRACE; ! 91: } ! 92: } ! 93: } ! 94: ! 95: BOUNDTRACE: ! 96: ! 97: SelectObject(hDC, hpnGreen); ! 98: if ((lpPt = pptTrace(o, p, pInfo, &iCount, hDC)) == NULL) ! 99: { ! 100: m = o+1; ! 101: ! 102: for (n=p; n<=rc.bottom; n++) { ! 103: c2 = y0 = XformFix(n, rc.top, rc.bottom, pInfo->lyFrom, pInfo->lyTo); ! 104: ! 105: while (m <= rc.right) ! 106: { ! 107: c1 = x0 = XformFix(m, rc.left, rc.right, pInfo->lxFrom, pInfo->lxTo); ! 108: Pt.x = m; ! 109: Pt.y = n; ! 110: ! 111: if (!bEscape(Pt, x0, y0, c1, c2, iIteration, rc)) ! 112: { ! 113: o = m; ! 114: p = n; ! 115: goto BOUNDTRACE; ! 116: } ! 117: ! 118: m++; ! 119: } ! 120: m = rc.left; ! 121: } ! 122: } ! 123: ! 124: if (!BeginPath(hDC)) { ! 125: sprintf( gtext,"Failing in BeginPath!\n"); ! 126: OutputDebugString( gtext ); ! 127: } ! 128: ! 129: MoveToEx(hDC, m, n, NULL); ! 130: Polyline(hDC, lpPt, iCount); ! 131: ! 132: if (EndPath(hDC)) { ! 133: StrokePath(hDC); ! 134: } ! 135: ! 136: // ! 137: // Stroking discards the path ! 138: // ! 139: if (!BeginPath(hDC)) { ! 140: sprintf( gtext,"Failing in BeginPath!\n"); ! 141: OutputDebugString( gtext ); ! 142: } ! 143: ! 144: MoveToEx(hDC, m, n, NULL); ! 145: Polyline(hDC, lpPt, iCount); ! 146: ! 147: if (EndPath(hDC)) { ! 148: // ! 149: // Convert the path to region ! 150: // ! 151: pInfo->hRgnPath = PathToRegion(hDC); ! 152: ! 153: #if 0 ! 154: // ! 155: // SelectClipPath doesn't seem to work at this time ! 156: // ! 157: if (SelectClipPath(hDC, RGN_COPY)) { ! 158: // ! 159: // Testing if the clip region is effective or not ! 160: // ! 161: //MoveToEx(hDC, 0, 0, NULL); ! 162: //GetClientRect(pInfo->hwnd, &rc); ! 163: //LineTo(hDC, rc.right, rc.bottom); ! 164: } ! 165: #endif ! 166: } ! 167: ! 168: if (pInfo->hRgnPath != (HRGN) NULL) { ! 169: if (SelectClipRgn(hDC, pInfo->hRgnPath) == ERROR) { ! 170: sprintf( gtext,"Error in Selecting clip region\n"); ! 171: OutputDebugString( gtext ); ! 172: goto EXIT; ! 173: } ! 174: // ! 175: // Testing if the clip region is effective or not ! 176: // ! 177: //MoveToEx(hDC, 0, 0, NULL); ! 178: //GetClientRect(pInfo->hwnd, &rc); ! 179: //LineTo(hDC, rc.right, rc.bottom); ! 180: } ! 181: ! 182: ! 183: EXIT: ! 184: ! 185: pInfo->dwElapsed = GetTickCount() - dwTick1; ! 186: pInfo->hBmpSaved = SaveBitmap(pInfo->hwnd); ! 187: pInfo->bDrawing = FALSE; ! 188: ! 189: ReleaseDC(pInfo->hwnd, hDC); ! 190: // ! 191: // GlobalAlloc was called in pptTrace for storing the boundary points ! 192: // ! 193: GlobalFree((HANDLE) lpPt); ! 194: ExitThread(0); ! 195: if (!CloseHandle(pInfo->hThrd)) ! 196: MessageBox(ghwndMain, "Failed in CloseHandle!", "Error", MB_OK); ! 197: ! 198: return TRUE; ! 199: } ! 200: ! 201: /******************************Public*Routine******************************\ ! 202: * ! 203: * pptTrace ! 204: * ! 205: * Effects: Given a boundary point, traces the whole boundary of the ! 206: * set by calling dwGetNextBoundaryPoint() repeatedly. Returns ! 207: * a pointer to an array of boundary points and also the count ! 208: * of boundary points in the array, if successful. Otherwise, ! 209: * returns null. ! 210: * m, n is the x, y coordinates of the pixel of the initial ! 211: * boundary point. ! 212: * ! 213: * Warnings: ! 214: * ! 215: * History: ! 216: * 20-Feb-1992 -by- Petrus Wong ! 217: * Wrote it. ! 218: \**************************************************************************/ ! 219: ! 220: LPPOINT pptTrace(LONG m, LONG n, PINFO pInfo, INT * piCount, HDC hDC) ! 221: { ! 222: DWORD dwFace; ! 223: LPPOINT lpPt, lpTmpPt; ! 224: POINT Init; ! 225: int iNumPt; ! 226: ! 227: // ! 228: // MAXPOINT points should be enough for storing the boundary for now. If ! 229: // it's not enough, it is more likely that it is an error. ! 230: // ! 231: if ((lpPt = (PPOINT) GlobalAlloc(GMEM_FIXED, MAXPOINT * sizeof(POINT))) == NULL) { ! 232: MessageBox(ghwndMain, "Failed in Memory Allocation for lpPt!", "Error", MB_OK); ! 233: return (LPPOINT) NULL; ! 234: } ! 235: lpTmpPt = lpPt; ! 236: lpPt->x = Init.x = m; ! 237: lpPt->y = Init.y = n; ! 238: lpPt++; ! 239: iNumPt = 1; ! 240: dwFace = dwGetNextBoundaryPoint(EAST, Init, lpPt, pInfo); ! 241: // ! 242: // If can't find next boundary point, return null ! 243: // ! 244: if (dwFace == 0) ! 245: return((LPPOINT)NULL); ! 246: //#if 0 ! 247: // ! 248: // remove the ifdef if we wanted to see the boundary as we trace ! 249: // ! 250: MoveToEx(hDC, Init.x, Init.y, NULL); ! 251: LineTo(hDC, lpPt->x, lpPt->y); ! 252: //#endif ! 253: // ! 254: // Keep looking for next boundary point until I get back to where I ! 255: // started or exceeding MAXPOINT points ! 256: // ! 257: while ((iNumPt < MAXPOINT) && ! 258: ((lpPt->x != lpTmpPt->x) || (lpPt->y != lpTmpPt->y))) { ! 259: Init.x = lpPt->x; ! 260: Init.y = lpPt->y; ! 261: lpPt++; ! 262: iNumPt++; ! 263: dwFace = dwGetNextBoundaryPoint(dwFace, Init, lpPt, pInfo); ! 264: // ! 265: // If can't find next boundary point, return null ! 266: // ! 267: if (dwFace == 0) ! 268: return((LPPOINT)NULL); ! 269: //#if 0 ! 270: // ! 271: // remove the ifdef if we wanted to see the boundary as we trace ! 272: // ! 273: MoveToEx(hDC, Init.x, Init.y, NULL); ! 274: LineTo(hDC, lpPt->x, lpPt->y); ! 275: //#endif ! 276: ! 277: } ! 278: // ! 279: // It is more likely that it is an error of the algorithm, if ever happens. ! 280: // ! 281: if (iNumPt >= MAXPOINT) { ! 282: MessageBox(ghwndMain, "Not enough memory!!", "Error", MB_OK); ! 283: } ! 284: *piCount = iNumPt; ! 285: return (LPPOINT) lpTmpPt; ! 286: } ! 287: ! 288: ! 289: /******************************Public*Routine******************************\ ! 290: * ! 291: * dwGetNextBoundaryPoint ! 292: * ! 293: * Effects: Start checking the 8 neighbors in clockwise direction. Returns ! 294: * the first neighbor that does not escape. ! 295: * dwFace where we face ! 296: * InitPt where we are right now in pixel coordinates ! 297: * ! 298: * Warnings: assumes that we start at a boundary point. Does not trace into ! 299: * a bay if the entrance closed. Ie, it cuts cycle. ! 300: * ! 301: * History: ! 302: * 12-Feb-1992 -by- Petrus Wong ! 303: * Wrote it. ! 304: \**************************************************************************/ ! 305: ! 306: DWORD dwGetNextBoundaryPoint(DWORD dwFace, POINT InitPt, LPPOINT lpPt, PINFO pInfo) ! 307: { ! 308: BOOL bEsc; ! 309: DWORD dwExplore; ! 310: DWORD dwEnd; ! 311: int i; ! 312: NODE arg[8]; ! 313: POINT BndPt; ! 314: LONG lx, c1, ly, c2; ! 315: RECT rc; ! 316: ! 317: GetClientRect(pInfo->hwnd, &rc); ! 318: // ! 319: // Start exploring clockwise, ending at where we came from ! 320: // ! 321: dwExplore = dwShift(dwFace, RIGHT, 3); ! 322: dwEnd = dwShift(dwFace, LEFT, 4); ! 323: i = 0; ! 324: bDirToPt(dwExplore, InitPt, &BndPt); ! 325: c1 = lx = XformFix(BndPt.x, rc.left, rc.right, pInfo->lxFrom, pInfo->lxTo); ! 326: c2 = ly = XformFix(BndPt.y, rc.top, rc.bottom, pInfo->lyFrom, pInfo->lyTo); ! 327: ! 328: while (bEsc = bEscape(BndPt, lx, ly, c1, c2, pInfo->iIteration, rc)) { ! 329: arg[i].dwDirection = dwExplore; ! 330: arg[i].bEscape = TRUE; ! 331: ! 332: i++; ! 333: ! 334: if (dwExplore == dwEnd) ! 335: break; ! 336: ! 337: dwExplore = dwShift(dwExplore, LEFT, 1); ! 338: bDirToPt(dwExplore, InitPt, &BndPt); ! 339: c1 = lx = XformFix(BndPt.x, rc.left, rc.right, pInfo->lxFrom, pInfo->lxTo); ! 340: c2 = ly = XformFix(BndPt.y, rc.top, rc.bottom, pInfo->lyFrom, pInfo->lyTo); ! 341: ! 342: } ! 343: ! 344: if (bEsc) { ! 345: return 0L; ! 346: } ! 347: ! 348: arg[i].dwDirection = dwExplore; ! 349: arg[i].bEscape = FALSE; ! 350: ! 351: bDirToPt(arg[i].dwDirection, InitPt, lpPt); ! 352: ! 353: return arg[i].dwDirection; ! 354: } ! 355: ! 356: ! 357: ! 358: /******************************Public*Routine******************************\ ! 359: * ! 360: * bEscape ! 361: * ! 362: * Effects: Test if the point excapes based on the number of iterations ! 363: * ! 364: * Warnings: ! 365: * ! 366: * History: ! 367: * 20-Feb-1992 -by- Petrus Wong ! 368: * Wrote it. ! 369: \**************************************************************************/ ! 370: ! 371: BOOL bEscape(POINT Pt, LONG x, LONG y, LONG c1, LONG c2, int iIteration, RECT rc) ! 372: { ! 373: LONG x1, y1, z; ! 374: BOOL bEscape; ! 375: int i; ! 376: ! 377: bEscape = FALSE; ! 378: ! 379: // ! 380: // Treat points outside of client rect as escaping ! 381: // ! 382: if ((Pt.x < rc.left) || (Pt.x > rc.right-1) || ! 383: (Pt.y > rc.bottom-1) || (Pt.y < rc.top)) { ! 384: return TRUE; ! 385: } ! 386: for (i=1; i<=iIteration; i++) { ! 387: x1 = lMul(x - y, x + y) + c1; ! 388: y1 = (lMul(x, y) * 2) + c2; ! 389: x = x1; ! 390: y = y1; // 2 2 2 1/2 2 ! 391: z = lMul(x, x) + lMul(y, y); // |Z| = ((x1 + x2 ) ) > 2 ! 392: ! 393: if (z > 8192) { ! 394: bEscape = TRUE; ! 395: break; ! 396: } ! 397: } ! 398: return bEscape; ! 399: } ! 400: ! 401: /******************************Public*Routine******************************\ ! 402: * ! 403: * bDirToPt ! 404: * ! 405: * Effects: Returns the pixel coordinates based the direction we are facing ! 406: * and our current position ! 407: * ! 408: * Warnings: ! 409: * ! 410: * History: ! 411: * 20-Feb-1992 ! 412: * Wrote it. ! 413: \**************************************************************************/ ! 414: ! 415: BOOL bDirToPt(DWORD dwDirection, POINT InitPt, LPPOINT lpPt) ! 416: { ! 417: BOOL bSuccess; ! 418: ! 419: bSuccess = TRUE; ! 420: switch ((LONG)dwDirection) { ! 421: case EAST: ! 422: lpPt->x = InitPt.x+1; ! 423: lpPt->y = InitPt.y; ! 424: break; ! 425: case SOUTHEAST: ! 426: lpPt->x = InitPt.x+1; ! 427: lpPt->y = InitPt.y+1; ! 428: break; ! 429: case SOUTH: ! 430: lpPt->x = InitPt.x; ! 431: lpPt->y = InitPt.y+1; ! 432: break; ! 433: case SOUTHWEST: ! 434: lpPt->x = InitPt.x-1; ! 435: lpPt->y = InitPt.y+1; ! 436: break; ! 437: case WEST: ! 438: lpPt->x = InitPt.x-1; ! 439: lpPt->y = InitPt.y; ! 440: break; ! 441: case NORTHWEST: ! 442: lpPt->x = InitPt.x-1; ! 443: lpPt->y = InitPt.y-1; ! 444: break; ! 445: case NORTH: ! 446: lpPt->x = InitPt.x; ! 447: lpPt->y = InitPt.y-1; ! 448: break; ! 449: case NORTHEAST: ! 450: lpPt->x = InitPt.x+1; ! 451: lpPt->y = InitPt.y-1; ! 452: break; ! 453: default: ! 454: bSuccess = FALSE; ! 455: break; ! 456: } ! 457: return bSuccess; ! 458: } ! 459: ! 460: /******************************Public*Routine******************************\ ! 461: * ! 462: * dwShift ! 463: * NORTH ! 464: * NW 0x0040 NE ! 465: * 0x0020 0x0080 ! 466: * Effects: WEST 0x0010 * 0x0001 EAST ! 467: * 0x0008 0x0002 ! 468: * SW 0x0004 SE ! 469: * SOUTH ! 470: * ! 471: * Shift dwOpnd left or right by iNum. ! 472: * dwOpnd contains the above values. The shift operation is ! 473: * closed. ! 474: * ! 475: * Warnings: ! 476: * ! 477: * History: ! 478: * 20-Feb-1992 -by- Petrus Wong ! 479: * Wrote it. ! 480: \**************************************************************************/ ! 481: ! 482: DWORD dwShift(DWORD dwOpnd, int iDir, int iNum) ! 483: { ! 484: DWORD dwTmp; ! 485: ! 486: dwTmp = ((dwOpnd << 8) | dwOpnd); ! 487: switch ((LONG)iDir) { ! 488: case LEFT: ! 489: dwTmp = dwTmp << iNum; ! 490: dwTmp = dwTmp & 0x0ff00; ! 491: dwTmp = dwTmp >> 8; ! 492: break; ! 493: case RIGHT: ! 494: dwTmp = dwTmp >> iNum; ! 495: dwTmp = dwTmp & 0x0ff; ! 496: break; ! 497: default: ! 498: dwTmp = 0L; ! 499: break; ! 500: } ! 501: return dwTmp; ! 502: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.