Annotation of QuadraticMandel/genfractal.c, revision 1.1
1.1 ! cvsmgr 1: /*******************************************************************************
! 2: +*
! 3: +* 9.12.2005
! 4: +*
! 5: +* $Id: genfractal.c,v 1.24 2010/03/16 17:42:39 rduran Exp $
! 6: +* $Name: $
! 7: +*
! 8: +* Falta por hacer el cálculo del mínimo A para Gc. Ahora se usa la
! 9: +* iteración especial con valor de 50.0
! 10: +*
! 11: *******************************************************************************/
! 12: # include <stdlib.h>
! 13: # include <stdio.h>
! 14: # include <string.h>
! 15: # include <math.h>
! 16: # include <stdarg.h>
! 17: # include "mypng.h"
! 18: # include "genfractal.h"
! 19: # include "mathutil.h"
! 20:
! 21: enum Zona {ZONA_Fbc_MAS, ZONA_Fbc_MENOS, ZONA_Fc_MAS, ZONA_Fc_MENOS, ZONA_Gc, ZONA_00};
! 22:
! 23: static double minA = 1.0;
! 24: static double a1 = 1.0;
! 25: static double b1 = 1.0;
! 26: static double c1 = 1.0;
! 27: static double a2 = 1.0;
! 28: static double b2 = 1.0;
! 29: static double c2 = 1.0;
! 30:
! 31: enum Zona zona = ZONA_Fbc_MAS;
! 32:
! 33: /*******************************************************************************
! 34: +* El siguiente if a 1 para imagen en color, 0 para blanco y negro.
! 35: *******************************************************************************/
! 36: # if 1
! 37: static void PNGColorAssign(png_colorp p, int iter, int itermax)
! 38: {
! 39: double ratio = 767.0*((double) iter / (double) itermax);
! 40: int c = lround(ratio);
! 41:
! 42: # if 0
! 43: if (c != 0 && c != 767) printf("iter: %d, ratio=%lf, c=%d\n", iter, ratio, c);
! 44: # endif
! 45: switch (c/256)
! 46: {
! 47: case 0:
! 48: p->blue = c%256;
! 49: # if 0
! 50: if (c!=0 && c!=255) printf("Caso 0\n");
! 51: # endif
! 52: break;
! 53:
! 54: case 1:
! 55: p->blue = 255 - c%256;
! 56: p->green = c%256;
! 57: # if 0
! 58: if (c!=0 && c!=255) printf("Caso 1\n");
! 59: # endif
! 60: break;
! 61:
! 62: default:
! 63: p->green = 255 - c%256;
! 64: p->red = c%256;
! 65: # if 0
! 66: if (c!=0 && c!=255) printf("Caso default\n");
! 67: # endif
! 68: }
! 69: }
! 70: # endif
! 71:
! 72: /*******************************************************************************
! 73: +* El siguiente if a 0 para imagen en color, 1 para blanco y negro.
! 74: *******************************************************************************/
! 75: # if 0
! 76: static void PNGColorAssign(png_colorp p, int iter, int itermax)
! 77: {
! 78: double ratio = 255.0*((double) iter / (double) itermax);
! 79:
! 80: /*******************************************************************************
! 81: +* El siguiente if a 1 para fondo blanco, fractal negro.
! 82: *******************************************************************************/
! 83: # if 1
! 84: p->blue = p->green = p->red = 255 - lround(ratio);
! 85: # endif
! 86: /*******************************************************************************
! 87: +* El siguiente if a 1 para fondo negro, fractal blanco.
! 88: *******************************************************************************/
! 89: # if 0
! 90: p->blue = p->green = p->red = lround(ratio);
! 91: # endif
! 92: }
! 93: # endif
! 94:
! 95: static double ComputeZR(double zr, double zi)
! 96: {
! 97: return a1*zr*zr + 2.0*b1*zr*zi + c1*zi*zi;
! 98: }
! 99:
! 100: static double ComputeZI(double zr, double zi)
! 101: {
! 102: return a2*zr*zr + 2.0*b2*zr*zi + c2*zi*zi;
! 103: }
! 104:
! 105: static double maximo(double a, double b)
! 106: {
! 107: if (a > b)
! 108: return a;
! 109: else
! 110: return b;
! 111: }
! 112:
! 113: static double minimo(double a, double b)
! 114: {
! 115: if (a < b)
! 116: return a;
! 117: else
! 118: return b;
! 119: }
! 120:
! 121: /*******************************************************************************
! 122: +* Función A_t para la parte F^+_{bc}
! 123: *******************************************************************************/
! 124: static double Ap_t(double t)
! 125: {
! 126: return pow(1. - pow(t,2),2)/pow(1. + pow(t,2),2) +
! 127: pow(t,2)/pow(1. + pow(t,2),2)*
! 128: (
! 129: pow(c1,2)*pow(t,2) +
! 130: 4.*pow(b1,2) +
! 131: 4.*b1*c1*t
! 132: );
! 133: }
! 134:
! 135:
! 136: static void ComputeMinAplus00(void)
! 137: {
! 138: double t = sqrt(2./(2.+pow(c1,2)));
! 139:
! 140: minA = minimo(minA, Ap_t(t));
! 141: minA = minimo(minA, Ap_t(-t));
! 142:
! 143: return;
! 144: }
! 145:
! 146: void ComputeMinAplus(void)
! 147: {
! 148: double k;
! 149: double p;
! 150: double q;
! 151: double d;
! 152: double rho;
! 153: double theta;
! 154: double l1q;
! 155: double l2q;
! 156: int i;
! 157:
! 158: k = (pow(c1,2)-2.*pow(b1,2)+2.)/(3.*b1*c1);
! 159: p = (-4.*k-3.*b1*c1-2.*pow(c1,2)*k+3.*b1*c1*pow(k,2)+4.*pow(b1,2)*k)/(b1*c1);
! 160: q = (-2.*pow(k,2)-3.*b1*c1*k+2+b1*c1*pow(k,3)-2.*pow(b1,2)+2.*pow(b1,2)*pow(k,2)-pow(c1,2)*pow(k,2))/(b1*c1);
! 161:
! 162: if ((d = 81.*pow(q,2)+12.*pow(p,3)) < 0.0)
! 163: {
! 164: l1q = q*q/4.;
! 165: l2q = -d/324.;
! 166: rho = sqrt(l1q + l2q);
! 167: theta = atan(sqrt(l2q/l1q));
! 168:
! 169: for (i = 0; i < 3; i++)
! 170: minA = minimo(minA, Ap_t(2.*pow(rho, 1./3.)*cos(theta/3. + 2.*i*M_PI/3.) + k));
! 171: }
! 172: else
! 173: {
! 174: fprintf(stderr, "#WARNING: Discriminante positivo, sólo hay una solución.\n");
! 175: minA = minimo(minA, Ap_t(pow(-q/2. + sqrt(d)/18.,1./3.) + pow(-q/2. - sqrt(d)/18.,1./3.) + k));
! 176: }
! 177:
! 178: return;
! 179: }
! 180:
! 181: /*******************************************************************************
! 182: +* Función A_t para la parte F^-_{bc}
! 183: *******************************************************************************/
! 184: static double Am_t(double t)
! 185: {
! 186: return 1 + pow(t,2)/pow(1. + pow(t,2),2)*
! 187: (
! 188: pow(c1,2)*pow(t,2) +
! 189: 4.*pow(b1,2) +
! 190: 4.*b1*c1*t
! 191: );
! 192: }
! 193:
! 194: static void ComputeMinAminus00(void)
! 195: {
! 196: if (b1 != 0.0)
! 197: {
! 198: minA = minimo(minA, Am_t(1.));
! 199: minA = minimo(minA, Am_t(-1.));
! 200: }
! 201:
! 202: return;
! 203: }
! 204:
! 205: static void ComputeMinAminus(void)
! 206: {
! 207: double k;
! 208: double p;
! 209: double q;
! 210: double d;
! 211: double rho;
! 212: double theta;
! 213: double l1q;
! 214: double l2q;
! 215: int i;
! 216:
! 217: k = (pow(c1,2)-2.*pow(b1,2))/(3.*b1*c1);
! 218: p = (4.*pow(b1,2)*k-2.*pow(c1,2)*k+3.*b1*c1*pow(k,2)-3.*b1*c1)/(b1*c1);
! 219: q = (-2.*pow(b1,2)+2.*pow(b1,2)*pow(k,2)-pow(c1,2)*pow(k,2)+b1*c1*pow(k,3)-3.*b1*c1*k)/(b1*c1);
! 220:
! 221: if ((d = 81.*pow(q,2)+12.*pow(p,3)) < 0.0)
! 222: {
! 223: l1q = q*q/4.;
! 224: l2q = -d/324.;
! 225: rho = sqrt(l1q + l2q);
! 226: theta = atan(sqrt(l2q/l1q));
! 227:
! 228: for (i = 0; i < 3; i++)
! 229: minA = minimo(minA, Am_t(2.*pow(rho, 1./3.)*cos(theta/3. + 2.*i*M_PI/3.) + k));
! 230: }
! 231: else
! 232: {
! 233: fprintf(stderr, "#WARNING: Discriminante positivo, sólo hay una solución.\n");
! 234: minA = minimo(minA, Am_t(pow(-q/2. + sqrt(d)/18.,1./3.) + pow(-q/2. - sqrt(d)/18.,1./3.) + k));
! 235: }
! 236:
! 237: return;
! 238: }
! 239:
! 240: /*******************************************************************************
! 241: +* Función A_t y sus derivadas para la parte F^+_{c}
! 242: *******************************************************************************/
! 243: static double AFcMas_t(double t)
! 244: {
! 245: return 1/pow(1. + pow(t,2),2)*
! 246: (
! 247: pow(c1,2)*pow(t,4) +
! 248: 4.*c1*pow(t,3) +
! 249: 4.*pow(t,2) +
! 250: 1.
! 251: );
! 252: }
! 253:
! 254: static void ComputeMinAFcMas0(void)
! 255: {
! 256:
! 257: minA = minimo(minA, AFcMas_t(sqrt(2.)/.2));
! 258: minA = minimo(minA, AFcMas_t(-sqrt(2.)/.2));
! 259:
! 260: return;
! 261: }
! 262:
! 263: static void ComputeMinAFcMas(void)
! 264: {
! 265: double k;
! 266: double p;
! 267: double q;
! 268: double d;
! 269: double rho;
! 270: double theta;
! 271: double l1q;
! 272: double l2q;
! 273: int i;
! 274:
! 275: k = 1./3.*(pow(c1,2)-2.)/c1;
! 276: p = (-2.*k*pow(c1,2) + 4.*k + 3.*c1*pow(k,2) - 3.*c1)/c1;
! 277: q = (-1. - pow(c1,2)*pow(k,2) + 2.*pow(k,2) + c1*pow(k,3) - 3.*c1*k)/c1;
! 278:
! 279: if ((d = 81.*pow(q,2)+12.*pow(p,3)) < 0.0)
! 280: {
! 281: l1q = q*q/4.;
! 282: l2q = -d/324.;
! 283: rho = sqrt(l1q + l2q);
! 284: theta = atan(sqrt(l2q/l1q));
! 285:
! 286: for (i = 0; i < 3; i++)
! 287: minA = minimo(minA, AFcMas_t(2.*pow(rho, 1./3.)*cos(theta/3. + 2.*i*M_PI/3.) + k));
! 288: }
! 289: else
! 290: {
! 291: fprintf(stderr, "#WARNING: Discriminante positivo, sólo hay una solución.\n");
! 292: minA = minimo(minA, AFcMas_t(pow(-q/2. + sqrt(d)/18.,1./3.) + pow(-q/2. - sqrt(d)/18.,1./3.) + k));
! 293: }
! 294:
! 295: return;
! 296: }
! 297:
! 298: /*******************************************************************************
! 299: +* Función A_t y sus derivadas para la parte F^-_{c}
! 300: *******************************************************************************/
! 301: static double AFcMenos_t(double t)
! 302: {
! 303: return 1/pow(1. + pow(t,2),2)*
! 304: (
! 305: pow(c1,2)*pow(t,4) -
! 306: 4.*c1*pow(t,3) +
! 307: 4.*pow(t,2) +
! 308: 1.
! 309: );
! 310: }
! 311:
! 312: static void ComputeMinAFcMenos0(void)
! 313: {
! 314:
! 315: minA = minimo(minA, AFcMenos_t(sqrt(2.)/.2));
! 316: minA = minimo(minA, AFcMenos_t(-sqrt(2.)/.2));
! 317:
! 318: return;
! 319: }
! 320:
! 321: static void ComputeMinAFcMenos(void)
! 322: {
! 323: double k;
! 324: double p;
! 325: double q;
! 326: double d;
! 327: double rho;
! 328: double theta;
! 329: double l1q;
! 330: double l2q;
! 331: int i;
! 332:
! 333: k = -1./3.*(pow(c1,2)-2.)/c1;
! 334: p = (2.*k*pow(c1,2) - 4.*k + 3.*c1*pow(k,2) - 3.*c1)/c1;
! 335: q = (1. + pow(c1,2)*pow(k,2) - 2.*pow(k,2) + c1*pow(k,3) - 3.*c1*k)/c1;
! 336:
! 337: if ((d = 81.*pow(q,2)+12.*pow(p,3)) < 0.0)
! 338: {
! 339: l1q = q*q/4.;
! 340: l2q = -d/324.;
! 341: rho = sqrt(l1q + l2q);
! 342: theta = atan(sqrt(l2q/l1q));
! 343:
! 344: for (i = 0; i < 3; i++)
! 345: minA = minimo(minA, AFcMenos_t(2.*pow(rho, 1./3.)*cos(theta/3. + 2.*i*M_PI/3.) + k));
! 346: }
! 347: else
! 348: {
! 349: fprintf(stderr, "#WARNING: Discriminante positivo, sólo hay una solución.\n");
! 350: minA = minimo(minA, AFcMenos_t(pow(-q/2. + sqrt(d)/18.,1./3.) + pow(-q/2. - sqrt(d)/18.,1./3.) + k));
! 351: }
! 352:
! 353: return;
! 354: }
! 355:
! 356: /*******************************************************************************
! 357: +* Función para la parte G_{c}
! 358: *******************************************************************************/
! 359: static void ComputeMinAGc(void)
! 360: {
! 361: double ypsilon;
! 362: double Ypsilon;
! 363: double tau1;
! 364:
! 365: ypsilon = 3*pow(c1,9) - 9*pow(c1,8) + 36*pow(c1,7) -
! 366: 111*pow(c1,6) + 540*pow(c1,5) - 1107*pow(c1,4) +
! 367: 2592*pow(c1,3) - 3321*pow(c1,2) + 6237*c1-10044;
! 368:
! 369: if (ypsilon > 0.0)
! 370: {
! 371: Ypsilon = pow((c1-1.)*pow(c1+1.,2) + sqrt(ypsilon)/9., 1./3.);
! 372: tau1 = (3*pow(Ypsilon,2) + 3*(1-c1)*Ypsilon -
! 373: (pow(c1,3)-pow(c1,2)+3*c1-15))/(3*c1*Ypsilon);
! 374: }
! 375: }
! 376:
! 377: /*******************************************************************************
! 378: +* Cálculo del mínimo de la B y computación del Modúlo máximo.
! 379: *******************************************************************************/
! 380:
! 381: static double ComputeMod2Max(double alpha, double beta)
! 382: {
! 383: double minB = 0.0;
! 384:
! 385: if (zona == ZONA_Fbc_MAS)
! 386: minB = c1*alpha - sqrt(pow(2.*b1*alpha,2)+pow(2.*beta-c1*alpha,2));
! 387: else if (zona == ZONA_Fbc_MENOS)
! 388: minB = c1*alpha+2.*beta - sqrt(pow(2.*b1*alpha,2)+pow(c1*alpha,2));
! 389: else if (zona == ZONA_Fc_MAS)
! 390: minB = beta + alpha*c1 - sqrt(pow(beta-alpha*c1,2) + 4.*pow(alpha,2));
! 391: else if (zona == ZONA_Fc_MENOS)
! 392: minB = beta + alpha*c1 - sqrt(pow(beta-alpha*c1,2) + 4.*pow(alpha,2));
! 393: else if (zona == ZONA_Gc)
! 394: minB = alpha*(c1 + 1.) - sqrt(pow(-c1+1.,2)*pow(alpha,2)+4.*pow(alpha-beta,2));
! 395: else if (zona == ZONA_00)
! 396: minB = -2.*sqrt(pow(alpha,2) + pow(beta,2));
! 397: else
! 398: {
! 399: fprintf(stderr, "#ERROR: Zona no implementada en el cálculo de min B.\n");
! 400: return 0.;
! 401: }
! 402:
! 403: return maximo(0., (1.-minB)/minA);
! 404: }
! 405:
! 406: /*******************************************************************************
! 407: +* Parte fija del cómputo.
! 408: *******************************************************************************/
! 409: static void IterComputation(png_colorpp image, int itermax)
! 410: {
! 411: int row, col, iter;
! 412: double mod2;
! 413: double mod2max;
! 414: double zrtemp, zitemp;
! 415: double zr, zi;
! 416: double cr, ci;
! 417: # if 0
! 418: png_color p;
! 419: # endif
! 420:
! 421: for (row = 0; row < NUM_ROWS; row++)
! 422: {
! 423: for (col = 0; col < NUM_COLS; col++)
! 424: {
! 425: cr = PixToCoordX(col);
! 426: ci = PixToCoordY(row);
! 427:
! 428: mod2max = ComputeMod2Max(cr, ci);
! 429:
! 430: zr = 0.0;
! 431: zi = 0.0;
! 432:
! 433: for (iter = 0; iter < itermax; iter++)
! 434: {
! 435: zrtemp = ComputeZR(zr, zi);
! 436: zitemp = ComputeZI(zr, zi);
! 437:
! 438: zr = zrtemp + cr;
! 439: zi = zitemp + ci;
! 440:
! 441: mod2 = zr*zr + zi*zi;
! 442: if (mod2 > mod2max)
! 443: {
! 444: # if 0
! 445: printf("Nos salimos en la: %d\n", iter);
! 446: # endif
! 447: break;
! 448: }
! 449: }
! 450: # if 0
! 451: if (iter >= itermax)
! 452: printf("Nos salimos por exceso, en (%lf, %lf)\n", cr, ci);
! 453: # endif
! 454:
! 455: PNGColorAssign(&image[row][col], iter, itermax);
! 456: }
! 457: }
! 458:
! 459: # if 0
! 460: p.red = 0; p.green = 255; p.blue = 0;
! 461: DrawHorizLine(image, 0.0, p);
! 462: DrawHorizLine(image, 1.0, p);
! 463: DrawHorizLine(image, -1.0, p);
! 464:
! 465: DrawVertiLine(image, 0.0, p);
! 466: DrawVertiLine(image, 1.0, p);
! 467: DrawVertiLine(image, -1.0, p);
! 468: # endif
! 469: }
! 470:
! 471: /*******************************************************************************
! 472: +* Parte fija del cómputo.
! 473: *******************************************************************************/
! 474: static void IterComputationEspecial(png_colorpp image, int itermax, double modmax)
! 475: {
! 476: int row, col, iter;
! 477: double mod2;
! 478: double mod2max;
! 479: double zrtemp, zitemp;
! 480: double zr, zi;
! 481: double cr, ci;
! 482: int flag_changed = 0,
! 483: mandel_zone = 0,
! 484: is_break = 0;
! 485: # if 0
! 486: png_color p;
! 487: # endif
! 488:
! 489: for (row = 0; row < NUM_ROWS; row++)
! 490: {
! 491: for (col = 0; col < NUM_COLS; col++)
! 492: {
! 493:
! 494: cr = PixToCoordX(col);
! 495: ci = PixToCoordY(row);
! 496:
! 497: mod2max = modmax;
! 498:
! 499: zr = 0.0;
! 500: zi = 0.0;
! 501:
! 502: is_break = 0;
! 503: for (iter = 0; iter < itermax; iter++)
! 504: {
! 505: zrtemp = ComputeZR(zr, zi);
! 506: zitemp = ComputeZI(zr, zi);
! 507:
! 508: zr = zrtemp + cr;
! 509: zi = zitemp + ci;
! 510:
! 511: mod2 = zr*zr + zi*zi;
! 512: if (mod2 > mod2max)
! 513: {
! 514: if (mandel_zone)
! 515: {
! 516: mandel_zone = 0;
! 517: flag_changed = 1;
! 518: }
! 519: is_break = 1;
! 520: break;
! 521: }
! 522: }
! 523: if (is_break == 0)
! 524: {
! 525: if (mandel_zone == 0)
! 526: {
! 527: mandel_zone = 1;
! 528: flag_changed = 1;
! 529: }
! 530: }
! 531: else
! 532: {
! 533: if (mandel_zone == 1)
! 534: {
! 535: mandel_zone = 0;
! 536: flag_changed = 1;
! 537: }
! 538: }
! 539:
! 540: if (flag_changed)
! 541: {
! 542: # if 0
! 543: printf("%15.10lf %15.10lf\n", cr, ci);
! 544: # endif
! 545: flag_changed = 0;
! 546: }
! 547:
! 548: PNGColorAssign(&image[row][col], iter, itermax);
! 549: }
! 550: # if 0
! 551: printf("\n");
! 552: # endif
! 553: }
! 554:
! 555: # if 0
! 556: p.red = 0; p.green = 255; p.blue = 0;
! 557: DrawHorizLine(image, 0.0, p);
! 558: DrawHorizLine(image, 1.0, p);
! 559: DrawHorizLine(image, -1.0, p);
! 560:
! 561: DrawVertiLine(image, 0.0, p);
! 562: DrawVertiLine(image, 1.0, p);
! 563: DrawVertiLine(image, -1.0, p);
! 564: # endif
! 565: }
! 566:
! 567: /*******************************************************************************
! 568: +* GenFractal
! 569: +* Genera la imagen fractal para las zonas \Delta^+ y \Delta^-
! 570: *******************************************************************************/
! 571: int GenFractal(char *img_name, double alpha,
! 572: double beta,
! 573: int itermax,
! 574: double side_len,
! 575: double offset_x,
! 576: double offset_y)
! 577: {
! 578: png_colorpp image = NULL;
! 579: png_text info_text[NUM_TEXT];
! 580: int status;
! 581: double c_temp;
! 582:
! 583: /*******************************************************************************
! 584: +* Parámetros de tamaño para la imagen. Reserva de memoria para ella.
! 585: *******************************************************************************/
! 586: SetSide(side_len);
! 587: SetOffsetX(offset_x);
! 588: SetOffsetY(offset_y);
! 589:
! 590: if (!(image = AllocatePNG(NUM_ROWS, NUM_COLS)))
! 591: return ERROR;
! 592:
! 593: BuildTextPtr(info_text, alpha, beta, itermax, side_len, offset_x, offset_y);
! 594:
! 595: /*******************************************************************************
! 596: +* Definición de la forma cuadrática.
! 597: +* Parte fija:
! 598: *******************************************************************************/
! 599: a1 = 0.0;
! 600: a2 = 1.0;
! 601: b2 = 0.0;
! 602:
! 603: /*******************************************************************************
! 604: +* Definición de la forma cuadrática.
! 605: +* Chequeo de condiciones sobre alpha y beta.
! 606: *******************************************************************************/
! 607: if (beta == 0.0) /* Beta ha de ser diferente de cero */
! 608: return ERROR;
! 609:
! 610: if ((alpha + 2.*beta) == 0.0) /* alpha + 2*beta != 0.0 */
! 611: return ERROR;
! 612:
! 613: /*******************************************************************************
! 614: +* Definición de la forma cuadrática.
! 615: +* Parte variable en función de alpha y beta:
! 616: *******************************************************************************/
! 617: c_temp = (4.*pow(alpha,3) - 27.*pow(beta,2))/pow(alpha + 2.*beta,3);
! 618:
! 619: if (c_temp < 0.0)
! 620: {
! 621: /* Zona F^-_{bc} */
! 622: c2 = 1.0;
! 623: zona = ZONA_Fbc_MENOS;
! 624: }
! 625: else
! 626: {
! 627: /* Zona F^+_{bc} */
! 628: c2 = -1.0;
! 629: zona = ZONA_Fbc_MAS;
! 630: }
! 631:
! 632: b1 = -c2*(alpha - beta)/(alpha + 2.*beta);
! 633: c1 = sqrt((-c2)*c_temp);
! 634:
! 635: if (zona == ZONA_Fbc_MAS)
! 636: {
! 637: if (c1 == 2.*b1 || c1 == -2.*b1)
! 638: {
! 639: fprintf(stderr, "#ERROR: Valores de b1 y c1 inválidos.\n");
! 640: return ERROR;
! 641: }
! 642: }
! 643:
! 644: /*******************************************************************************
! 645: +* Cálculo del mínimo de A, según valores de b1, c1 y zonas.
! 646: *******************************************************************************/
! 647: minA = 1.;
! 648: if (zona == ZONA_Fbc_MAS)
! 649: {
! 650: if (b1 == 0.0 || c1 == 0.0)
! 651: ComputeMinAplus00();
! 652: else
! 653: ComputeMinAplus();
! 654: }
! 655: else if (zona == ZONA_Fbc_MENOS)
! 656: {
! 657: if (b1 == 0.0 || c1 == 0.0)
! 658: ComputeMinAminus00();
! 659: else
! 660: ComputeMinAminus();
! 661: }
! 662: else
! 663: {
! 664: fprintf(stderr, "#ERROR: Zona no implementada.\n");
! 665: return ERROR;
! 666: }
! 667:
! 668: /*******************************************************************************
! 669: +* Computación y generación de la imagen.
! 670: *******************************************************************************/
! 671: IterComputation(image, itermax);
! 672: status = WritePNG(img_name, image, info_text, NUM_TEXT);
! 673: DeallocatePNG(image, NUM_ROWS, NUM_COLS);
! 674: return status;
! 675: }
! 676:
! 677: /*******************************************************************************
! 678: +* GenFractal
! 679: +* Genera la imagen fractal para las zonas C^+ y C^-
! 680: *******************************************************************************/
! 681: int GenFractalLinear(char *img_name, double alpha,
! 682: double beta,
! 683: int itermax,
! 684: double side_len,
! 685: double offset_x,
! 686: double offset_y)
! 687: {
! 688: png_colorpp image = NULL;
! 689: png_text info_text[NUM_TEXT];
! 690: int status;
! 691:
! 692: /*******************************************************************************
! 693: +* Parámetros de tamaño para la imagen. Reserva de memoria para ella.
! 694: *******************************************************************************/
! 695: SetSide(side_len);
! 696: SetOffsetX(offset_x);
! 697: SetOffsetY(offset_y);
! 698:
! 699: if (!(image = AllocatePNG(NUM_ROWS, NUM_COLS)))
! 700: return ERROR;
! 701:
! 702: BuildTextPtr(info_text, alpha, beta, itermax, side_len, offset_x, offset_y);
! 703:
! 704: /*******************************************************************************
! 705: +* Definición de la forma cuadrática.
! 706: +* Parte fija:
! 707: *******************************************************************************/
! 708: a1 = 0.0;
! 709: a2 = 1.0;
! 710: b2 = 0.0;
! 711: c2 = 0.0;
! 712:
! 713: /*******************************************************************************
! 714: +* Definición de la forma cuadrática.
! 715: +* Chequeo de condiciones sobre beta.
! 716: *******************************************************************************/
! 717: if (beta == 0.0) /* Beta ha de ser diferente de cero */
! 718: return ERROR;
! 719:
! 720: if (alpha + 2.*beta != 0.0)
! 721: return ERROR; /* alpha + 2*beta ha de ser cero */
! 722:
! 723: /*******************************************************************************
! 724: +* Definición de la forma cuadrática.
! 725: +* Parte variable en función de beta: setting de zonas.
! 726: *******************************************************************************/
! 727: if (beta*(27.0+32.0*beta) < 0.0)
! 728: {
! 729: b1 = -1.0;
! 730: zona = ZONA_Fc_MENOS;
! 731: }
! 732: else
! 733: {
! 734: b1 = 1.0;
! 735: zona = ZONA_Fc_MAS;
! 736: }
! 737:
! 738: c1 = b1/9.0*sqrt(fabs(3.0*(27.0+32.0*beta)/beta));
! 739:
! 740: /*******************************************************************************
! 741: +* Cálculo del mínimo de A, según valores de b1, c1 y zonas.
! 742: *******************************************************************************/
! 743: minA = 1.;
! 744: if (zona == ZONA_Fc_MAS)
! 745: {
! 746: if (c1 == 0.0)
! 747: ComputeMinAFcMas0();
! 748: else
! 749: ComputeMinAFcMas();
! 750: }
! 751: else if (zona == ZONA_Fc_MENOS)
! 752: {
! 753: if (c1 == 0.0)
! 754: ComputeMinAFcMenos0();
! 755: else
! 756: ComputeMinAFcMenos();
! 757: }
! 758: else
! 759: {
! 760: fprintf(stderr, "#ERROR: Zona no implementada.\n");
! 761: return ERROR;
! 762: }
! 763:
! 764: /*******************************************************************************
! 765: +* Computación y generación de la imagen.
! 766: *******************************************************************************/
! 767: IterComputation(image, itermax);
! 768: status = WritePNG(img_name, image, info_text, NUM_TEXT);
! 769: DeallocatePNG(image, NUM_ROWS, NUM_COLS);
! 770: return status;
! 771: }
! 772:
! 773: /*******************************************************************************
! 774: +* GenFractal
! 775: +* Genera la imagen fractal para el eje X (menos el origen).
! 776: *******************************************************************************/
! 777: int GenFractalAlpha(char *img_name, double alpha,
! 778: double beta,
! 779: int itermax,
! 780: double side_len,
! 781: double offset_x,
! 782: double offset_y)
! 783: {
! 784: png_colorpp image = NULL;
! 785: png_text info_text[NUM_TEXT];
! 786: int status;
! 787:
! 788: /*******************************************************************************
! 789: +* Parámetros de tamaño para la imagen. Reserva de memoria para ella.
! 790: *******************************************************************************/
! 791: SetSide(side_len);
! 792: SetOffsetX(offset_x);
! 793: SetOffsetY(offset_y);
! 794:
! 795: if (!(image = AllocatePNG(NUM_ROWS, NUM_COLS)))
! 796: return ERROR;
! 797:
! 798: BuildTextPtr(info_text, alpha, beta, itermax, side_len, offset_x, offset_y);
! 799:
! 800: /*******************************************************************************
! 801: +* Definición de la forma cuadrática.
! 802: +* Parte fija:
! 803: *******************************************************************************/
! 804: a1 = 1.0;
! 805: a2 = 0.0;
! 806: b1 = 1.0;
! 807: b2 = -1.0;
! 808: c2 = 0.0;
! 809:
! 810: /*******************************************************************************
! 811: +* Definición de la forma cuadrática.
! 812: +* Chequeo de condiciones sobre alpha y beta, y setting de zona.
! 813: *******************************************************************************/
! 814: if (alpha == 0.0 || beta != 0.0) /* Alpha ha de ser diferente de cero */
! 815: return ERROR; /* y beta igual a cero. */
! 816:
! 817: zona = ZONA_Gc;
! 818:
! 819: /*******************************************************************************
! 820: +* Definición de la forma cuadrática.
! 821: +* Parte variable en función de alpha:
! 822: *******************************************************************************/
! 823:
! 824: c1 = (4.0*alpha - 9.0)/alpha/12.0;
! 825:
! 826: /*******************************************************************************
! 827: +* Cálculo del mínimo de A, según valores de b1, c1 y zonas.
! 828: *******************************************************************************/
! 829: ComputeMinAGc();
! 830: minA = 1.;
! 831:
! 832: # if 0
! 833: if (zona == ZONA_Gc)
! 834: {
! 835: fprintf(stderr, "#ERROR: Zona no implementada.\n");
! 836: return ERROR;
! 837: }
! 838: else
! 839: {
! 840: fprintf(stderr, "#ERROR: Zona no implementada.\n");
! 841: return ERROR;
! 842: }
! 843: # endif
! 844:
! 845: /*******************************************************************************
! 846: +* Computación y generación de la imagen.
! 847: *******************************************************************************/
! 848: # if 0
! 849: IterComputation(image, itermax);
! 850: # endif
! 851: IterComputationEspecial(image, itermax, 50.0);
! 852: status = WritePNG(img_name, image, info_text, NUM_TEXT);
! 853: DeallocatePNG(image, NUM_ROWS, NUM_COLS);
! 854: return status;
! 855: }
! 856:
! 857: /*******************************************************************************
! 858: +* GenFractal_00
! 859: +* Genera la imagen fractal para el punto origen (0,0)
! 860: *******************************************************************************/
! 861: int GenFractal_00(char *img_name, double alpha,
! 862: double beta,
! 863: int itermax,
! 864: double side_len,
! 865: double offset_x,
! 866: double offset_y)
! 867: {
! 868: png_colorpp image = NULL;
! 869: png_text info_text[NUM_TEXT];
! 870: int status;
! 871:
! 872: /*******************************************************************************
! 873: +* Parámetros de tamaño para la imagen. Reserva de memoria para ella.
! 874: *******************************************************************************/
! 875: SetSide(side_len);
! 876: SetOffsetX(offset_x);
! 877: SetOffsetY(offset_y);
! 878:
! 879: if (!(image = AllocatePNG(NUM_ROWS, NUM_COLS)))
! 880: return ERROR;
! 881:
! 882: BuildTextPtr(info_text, alpha, beta, itermax, side_len, offset_x, offset_y);
! 883:
! 884: /*******************************************************************************
! 885: +* Definición de la forma cuadrática.
! 886: *******************************************************************************/
! 887: a1 = 0.0;
! 888: b1 = 1.0;
! 889: c1 = 0.0;
! 890: a2 = 1.0;
! 891: b2 = 0.0;
! 892: c2 = -1.0;
! 893:
! 894: /*******************************************************************************
! 895: +* Chequeo de condiciones sobre alpha y beta. Setting de zona.
! 896: *******************************************************************************/
! 897: if (alpha != 0.0 || beta != 0.0) /* Alfa y Beta han de ser cero. */
! 898: return ERROR;
! 899:
! 900: zona = ZONA_00;
! 901:
! 902: /*******************************************************************************
! 903: +* Cálculo del mínimo de A, según valores de b1, c1 y zonas.
! 904: *******************************************************************************/
! 905: minA = 1.;
! 906: if (zona == ZONA_00)
! 907: {
! 908: minA = 1.;
! 909: }
! 910: else
! 911: {
! 912: fprintf(stderr, "#ERROR: Zona no implementada.\n");
! 913: return ERROR;
! 914: }
! 915:
! 916: /*******************************************************************************
! 917: +* Computación y generación de la imagen.
! 918: *******************************************************************************/
! 919: IterComputation(image, itermax);
! 920: status = WritePNG(img_name, image, info_text, NUM_TEXT);
! 921: DeallocatePNG(image, NUM_ROWS, NUM_COLS);
! 922: return status;
! 923: }
! 924:
! 925: /*******************************************************************************
! 926: +* GenFractalEspecial1
! 927: +* Genera la imagen para F^+_c cuando c = 0.
! 928: *******************************************************************************/
! 929: int GenFractalEspecial1(char *img_name, double alpha,
! 930: double beta,
! 931: int itermax,
! 932: double side_len,
! 933: double offset_x,
! 934: double offset_y)
! 935: {
! 936: png_colorpp image = NULL;
! 937: png_text info_text[NUM_TEXT];
! 938: int status;
! 939:
! 940: /*******************************************************************************
! 941: +* Parámetros de tamaño para la imagen. Reserva de memoria para ella.
! 942: *******************************************************************************/
! 943: SetSide(side_len);
! 944: SetOffsetX(offset_x);
! 945: SetOffsetY(offset_y);
! 946:
! 947: if (!(image = AllocatePNG(NUM_ROWS, NUM_COLS)))
! 948: return ERROR;
! 949:
! 950: BuildTextPtr(info_text, alpha, beta, itermax, side_len, offset_x, offset_y);
! 951:
! 952: /*******************************************************************************
! 953: +* Definición de la forma cuadrática.
! 954: *******************************************************************************/
! 955: a1 = 0.0;
! 956: b1 = 1.0;
! 957: c1 = 0.0;
! 958: a2 = 1.0;
! 959: b2 = 0.0;
! 960: c2 = 0.0;
! 961:
! 962: IterComputationEspecial(image, itermax, 20.0);
! 963: status = WritePNG(img_name, image, info_text, NUM_TEXT);
! 964: DeallocatePNG(image, NUM_ROWS, NUM_COLS);
! 965: return status;
! 966: }
! 967:
! 968: /*******************************************************************************
! 969: +* GenFractalEspecial2
! 970: +* Genera la imagen para F^-_c cuando c = 0.
! 971: *******************************************************************************/
! 972: int GenFractalEspecial2(char *img_name, double alpha,
! 973: double beta,
! 974: int itermax,
! 975: double side_len,
! 976: double offset_x,
! 977: double offset_y)
! 978: {
! 979: png_colorpp image = NULL;
! 980: png_text info_text[NUM_TEXT];
! 981: int status;
! 982:
! 983: /*******************************************************************************
! 984: +* Parámetros de tamaño para la imagen. Reserva de memoria para ella.
! 985: *******************************************************************************/
! 986: SetSide(side_len);
! 987: SetOffsetX(offset_x);
! 988: SetOffsetY(offset_y);
! 989:
! 990: if (!(image = AllocatePNG(NUM_ROWS, NUM_COLS)))
! 991: return ERROR;
! 992:
! 993: BuildTextPtr(info_text, alpha, beta, itermax, side_len, offset_x, offset_y);
! 994:
! 995: /*******************************************************************************
! 996: +* Definición de la forma cuadrática.
! 997: *******************************************************************************/
! 998: a1 = 0.0;
! 999: b1 = -1.0;
! 1000: c1 = 0.0;
! 1001: a2 = 1.0;
! 1002: b2 = 0.0;
! 1003: c2 = 0.0;
! 1004:
! 1005: IterComputationEspecial(image, itermax, 20.0);
! 1006: status = WritePNG(img_name, image, info_text, NUM_TEXT);
! 1007: DeallocatePNG(image, NUM_ROWS, NUM_COLS);
! 1008: return status;
! 1009: }
! 1010:
! 1011: /*******************************************************************************
! 1012: +* GenFractalEspecial3
! 1013: +* Genera la imagen para G^_c cuando c = 0.
! 1014: *******************************************************************************/
! 1015: int GenFractalEspecial3(char *img_name, double alpha,
! 1016: double beta,
! 1017: int itermax,
! 1018: double side_len,
! 1019: double offset_x,
! 1020: double offset_y)
! 1021: {
! 1022: png_colorpp image = NULL;
! 1023: png_text info_text[NUM_TEXT];
! 1024: int status;
! 1025:
! 1026: /*******************************************************************************
! 1027: +* Parámetros de tamaño para la imagen. Reserva de memoria para ella.
! 1028: *******************************************************************************/
! 1029: SetSide(side_len);
! 1030: SetOffsetX(offset_x);
! 1031: SetOffsetY(offset_y);
! 1032:
! 1033: if (!(image = AllocatePNG(NUM_ROWS, NUM_COLS)))
! 1034: return ERROR;
! 1035:
! 1036: BuildTextPtr(info_text, alpha, beta, itermax, side_len, offset_x, offset_y);
! 1037:
! 1038: /*******************************************************************************
! 1039: +* Definición de la forma cuadrática.
! 1040: *******************************************************************************/
! 1041: a1 = 1.0;
! 1042: b1 = 1.0;
! 1043: c1 = 0.0;
! 1044: a2 = 0.0;
! 1045: b2 = -1.0;
! 1046: c2 = 0.0;
! 1047:
! 1048: IterComputationEspecial(image, itermax, 20.0);
! 1049: status = WritePNG(img_name, image, info_text, NUM_TEXT);
! 1050: DeallocatePNG(image, NUM_ROWS, NUM_COLS);
! 1051: return status;
! 1052: }
! 1053:
! 1054: /*******************************************************************************
! 1055: +* GenFractalEspecial5
! 1056: +* Genera el caso F^+_{00}
! 1057: *******************************************************************************/
! 1058: int GenFractalEspecial5(char *img_name, double alpha,
! 1059: double beta,
! 1060: int itermax,
! 1061: double side_len,
! 1062: double offset_x,
! 1063: double offset_y)
! 1064: {
! 1065: png_colorpp image = NULL;
! 1066: png_text info_text[NUM_TEXT];
! 1067: int status;
! 1068:
! 1069: /*******************************************************************************
! 1070: +* Parámetros de tamaño para la imagen. Reserva de memoria para ella.
! 1071: *******************************************************************************/
! 1072: SetSide(side_len);
! 1073: SetOffsetX(offset_x);
! 1074: SetOffsetY(offset_y);
! 1075:
! 1076: if (!(image = AllocatePNG(NUM_ROWS, NUM_COLS)))
! 1077: return ERROR;
! 1078:
! 1079: BuildTextPtr(info_text, alpha, beta, itermax, side_len, offset_x, offset_y);
! 1080:
! 1081: /*******************************************************************************
! 1082: +* Definición de la forma cuadrática.
! 1083: *******************************************************************************/
! 1084: a1 = 0.0;
! 1085: b1 = 0.0;
! 1086: c1 = 0.0;
! 1087: a2 = 1.0;
! 1088: b2 = 0.0;
! 1089: c2 = -1.0;
! 1090:
! 1091: IterComputationEspecial(image, itermax, 40.0);
! 1092: status = WritePNG(img_name, image, info_text, NUM_TEXT);
! 1093: DeallocatePNG(image, NUM_ROWS, NUM_COLS);
! 1094: return status;
! 1095: }
! 1096:
! 1097: /*******************************************************************************
! 1098: +* GenFractalEspecial6
! 1099: +* Genera el caso F^-_{00}
! 1100: *******************************************************************************/
! 1101: int GenFractalEspecial6(char *img_name, double alpha,
! 1102: double beta,
! 1103: int itermax,
! 1104: double side_len,
! 1105: double offset_x,
! 1106: double offset_y)
! 1107: {
! 1108: png_colorpp image = NULL;
! 1109: png_text info_text[NUM_TEXT];
! 1110: int status;
! 1111:
! 1112: /*******************************************************************************
! 1113: +* Parámetros de tamaño para la imagen. Reserva de memoria para ella.
! 1114: *******************************************************************************/
! 1115: SetSide(side_len);
! 1116: SetOffsetX(offset_x);
! 1117: SetOffsetY(offset_y);
! 1118:
! 1119: if (!(image = AllocatePNG(NUM_ROWS, NUM_COLS)))
! 1120: return ERROR;
! 1121:
! 1122: BuildTextPtr(info_text, alpha, beta, itermax, side_len, offset_x, offset_y);
! 1123:
! 1124: /*******************************************************************************
! 1125: +* Definición de la forma cuadrática.
! 1126: *******************************************************************************/
! 1127: a1 = 0.0;
! 1128: b1 = 0.0;
! 1129: c1 = 0.0;
! 1130: a2 = 1.0;
! 1131: b2 = 0.0;
! 1132: c2 = 1.0;
! 1133:
! 1134: IterComputationEspecial(image, itermax, 40.0);
! 1135: status = WritePNG(img_name, image, info_text, NUM_TEXT);
! 1136: DeallocatePNG(image, NUM_ROWS, NUM_COLS);
! 1137: return status;
! 1138: }
! 1139:
! 1140: /*******************************************************************************
! 1141: +* GenFractalEspecial7
! 1142: +* Genera el caso F^+_{bc} cuando $c=\pm 2b$
! 1143: *******************************************************************************/
! 1144: int GenFractalEspecial7(char *img_name, double alpha,
! 1145: double beta,
! 1146: int itermax,
! 1147: double side_len,
! 1148: double offset_x,
! 1149: double offset_y)
! 1150: {
! 1151: png_colorpp image = NULL;
! 1152: png_text info_text[NUM_TEXT];
! 1153: int status;
! 1154:
! 1155: /*******************************************************************************
! 1156: +* Parámetros de tamaño para la imagen. Reserva de memoria para ella.
! 1157: *******************************************************************************/
! 1158: SetSide(side_len);
! 1159: SetOffsetX(offset_x);
! 1160: SetOffsetY(offset_y);
! 1161:
! 1162: if (!(image = AllocatePNG(NUM_ROWS, NUM_COLS)))
! 1163: return ERROR;
! 1164:
! 1165: BuildTextPtr(info_text, alpha, beta, itermax, side_len, offset_x, offset_y);
! 1166:
! 1167: /*******************************************************************************
! 1168: +* Definición de la forma cuadrática.
! 1169: +* Parte fija:
! 1170: *******************************************************************************/
! 1171: a1 = 0.0;
! 1172: a2 = 1.0;
! 1173: b2 = 0.0;
! 1174: c2 = -1.0;
! 1175: b1 = beta;
! 1176: c1 = 2*beta;
! 1177:
! 1178: /*******************************************************************************
! 1179: +* Computación y generación de la imagen.
! 1180: *******************************************************************************/
! 1181: IterComputationEspecial(image, itermax, 40.0);
! 1182: status = WritePNG(img_name, image, info_text, NUM_TEXT);
! 1183: DeallocatePNG(image, NUM_ROWS, NUM_COLS);
! 1184: return status;
! 1185: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genfractal.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository ATC2] / QuadraticMandel