SoloCodigo
Programación General => C/C++ => Mensaje iniciado por: luchojimenez en Viernes 22 de Junio de 2012, 20:35
-
bueno estoy trabajando en codigo sobre las curvas de koch en c++ y borland c++ 5.5 todavia no he logrado resultados validos mas sin embargos les adjunto lo que he trabajado ahsta ahora para a ver si alguien por hay puede hacerme una correcion de lo estoy haciendo
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<graphics.h>
#include<math.h>
#define pi 3.141516
class tortuga{
private:
double x;
double y;
double ang;
public:
void tortuga(double x,double y,double ang)
{
tortuga.x=x;
tortuga.y=y;
tortuga.ang=ang*pi/180;
}
void salta(double distancia)
{
double xx=x+distancia*cos(ang);
double yy=y-distancia*sin(ang);
salta(xx, yy);
}
void salta(double x, double y)
{
this.x=x;
this.y=y;
}
void gira(double ang)
{
this.angulo+=angulo*pi/180;
}
void traza(double distancia){
double xx=x+distancia*Math.cos(angulo);
double yy=y-distancia*Math.sin(angulo);
Line(xx, yy, x,y);
salta(xx, yy);
}
};
void generaKoch(int nivel, double distancia){
if(nivel==0){
tortuga.traza(distancia);
}else{
generaKoch(nivel-1, distancia/3);
tortuga::gira(60.0);
generaKoch(nivel-1, distancia/3);
tortuga::gira(-120.0);
generaKoch(nivel-1, distancia/3);
tortuga:gira(60);
generaKoch(nivel-1, distancia/3);
}
}
void main()
{
int gdriver = DETECT, gmode,n=6;
double d=50;
initgraph(&gdriver, &gmode, "c:\\tc\\bgi");
generaKoch(n,d);
system("pause");
closegraph();
}
-
bueno compañeros hastra aqui levo el codigo todavia no soy capaz de lograr que dibuje la curva de koch mas sin embargo llevo avances , estoy tratanto de utilizar el metodo de la tortuga para sistemas de lindemayer y crear fractales , en el momento quiero lograr una funcion recursiva que me dibuje en varios niveles el fractal o curva de koch
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<graphics.h>
#include<dos.h>
#define pi 3.141516
void f(double x1,double y1,double ang,double d1);
double F(int dx,double x ,double y,double d1);
int k,tet;
void main()
{
int gdriver = DETECT, gmode;
initgraph(&gdriver, &gmode, "c:\\tc\\bgi");
k=0;
for(int n=1,tet=60;n<=15,tet<=500;n++,tet=tet+60)
F(k=k+tet,100,200,50);
system("pause");
closegraph();
}
void f(double x1,double y1,double ang,double d1)
{
double x,y;
d1=0;
do
{
x=x1 + cos(ang)*d1;
y=y1 + sin(ang)*d1;
putpixel(x,y,14);
d1=d1+0.005;
}while(d1<=100);
}
double F(int dx,double x,double y,double d1)
{
int a=0;
double conv,omeg;
conv=pi/180;
omeg=dx*conv;
dx=omeg;
f(x,y,a,d1);
f(x+cos(a)*100,y+sin(a)*100,a-dx,d1);
f(x+cos(a)*100+cos(a-dx)*100,y+sin(a)*100+sin(a-dx)*100,a+dx,d1);
f(x+cos(a)*100+cos(a-dx)*100+cos(a+dx)*100,y+sin(a)*100+sin(a-dx)*100+sin(a+dx)*100,a,d1);
return 0;
}
-
bueno como nadie se ha animado ha colaborarme yo voy a tomar este post como una bitacora y referencias para futuros trabajos que lo requieran.
por otro lado navegando por internet encontre este mate en la pagina de c.conclase.net
La curva de Koch se construye dividiendo un segmento en tres partes iguales. El segundo segmento - el segmento del medio - forma la base de un triángulo equilátero, pero sin representar este segmento - la base. Esto significa que tenemos un segmento horizontal seguido de dos segmentos, estos dos últimos en forma de triángulo, y luego seguido de un tercer segmento horizontal. Esta estructura es la primitiva para construir esta curva. En siguientes repeticiones, cada segmento de esta curva primitiva es a su vez sometido al mismo algoritmo: segmento horizontal seguido de dos segmentos terminando en la "punta" de un triángulo equilátero y seguido por un tercer segmento horizontal.
La estructura primitiva se puede definir usando la siguiente regla o axioma de producción:
A → AIADDAIA,
donde A indica avanzar, lo cual implica trazar una línea recta,
I es girar a la izquierda, y
D es girar a la derecha.
En el caso de la curva de Koch, cada giro se hace con un ángulo de 60° = π/3 radianes. Los ángulos son 60° porque la curva de Koch se construye en base a un triángulo equilátero. Todos los ángulos de un triángulo equilátero son 60°.
Podemos observar el estado inicial de la curva de Koch, que simplemente es una línea recta, en la Siguiendo la regla que tenemos, avanzamos una sola vez.
Para la primera iteración, obtenemos la secuencia: AIADDAIA con un ángulo de giro de 60°. Realmente estamos sustituyendo la regla de avanzar, inicialmente establecida, por la secuencia descrita por la regla de producción:
1. Avanzar el primer tercio.
2. Girar 60° a la izquierda.
3. Avanzar otro tercio.
4. Girar 60° a la derecha.
5. Girar 60° a la derecha.
6. Avanzar otro tercio.
7. Girar 60° a la izquierda.
8. Avanzar el último tercio.
En la segunda iteración, realizamos el mismo método basándonos en nuestra regla de producción. Aplicamos: A → AIADDAIA para cada 'A'. Esto implica que sustituimos cada 'A' por su definición para lograr el siguiente producto: AIADDAIA I AIADDAIA DD AIADDAIA I AIADDAIA. He aquí el elemento recursivo. Al seguir esta regla obtenemos una imagen
odríamos reescribir la definición de esta regla para reflejar la recursividad:
A0 → Avanzar
An+1 → AnIAnDDAnIAn
donde n indica el número de repeticiones.
Para trazar estas líneas y seguir la regla de producción, nos basamos en la idea de un cursor gráfico. Este cursor contiene una pareja de coordenadas que describe su posición actual y un ángulo que describe su orientación. Necesitamos definir previamente la longitud inicial de A0. Cada vez que "avancemos", calculamos la siguiente posición usando a) la posición actual del cursor como punto inicial, b) tomando un tercio de la longitud inicial, y c) aplicando trigonometría (senos y cosenos) con el ángulo del cursor. La razón de usar un tercio de la longitud es para reducir el tamaño de cada figura para que la imagen final se limite a una distancia adecuada. Si usáramos la misma longitud inicial para cada segmento, entonces obtendríamos una imagen bastante grande cuantas más iteraciones hiciéramos; es decir, cuanto mayor sea el valor de n. La imagen sería tan grande que posiblemente parte de ella sobresalga la pantalla. Por esta razón, optamos por dividir el segmento inicial en partes de menor longitud, para que la curva final sea más manejable.
-
ahora voy a intentar realizar la siguiente funcion el cual tenemos por algoritmo en borland c++
Real Avanzar( Cursor, D )
1. Declarar P como un punto: (x,y)
2. P.x ← Cursor.punto.x + D*cos( Cursor.ángulo )
3. P.y ← Cursor.punto.y + D*sen( Cursor.ángulo )
4. Dibujar_Línea( Cursor.punto.x, Cursor.punto.y, P.x, P.y )
5. Terminar( P )
si me equivoco por favor corregirme
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<graphics.h>
#include<dos.h>
#define pi 3.141516
struct cursor
{
float x;
float y;
float ang;
};
float avanzar(float*cursor,D)
{
struct punto{
float x;
float y;
};
punto= new cursor;
p=new punto;
p.x=Cursor.punto.x + D*cos( Cursor.ángulo );
p.y=Cursor.punto.y + D*sen( Cursor.ángulo );
line(Cursor.punto.x, Cursor.punto.y, P.x, P.y );
delete punto;
delete p;
}
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm," ");
closegraph();
}
todfavia no es funcional hay que depurar y solo estoy confeccionando las funcionesbueno estoy trabajando en codigo sobre las curvas de koch en c++ y borland c++ 5.5 todavia no he logrado resultados validos mas sin embargos les adjunto lo que he trabajado ahsta ahora para a ver si alguien por hay puede hacerme una correcion de lo estoy haciendo
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<graphics.h>
#include<math.h>
#define pi 3.141516
class tortuga{
private:
double x;
double y;
double ang;
public:
void tortuga(double x,double y,double ang)
{
tortuga.x=x;
tortuga.y=y;
tortuga.ang=ang*pi/180;
}
void salta(double distancia)
{
double xx=x+distancia*cos(ang);
double yy=y-distancia*sin(ang);
salta(xx, yy);
}
void salta(double x, double y)
{
this.x=x;
this.y=y;
}
void gira(double ang)
{
this.angulo+=angulo*pi/180;
}
void traza(double distancia){
double xx=x+distancia*Math.cos(angulo);
double yy=y-distancia*Math.sin(angulo);
Line(xx, yy, x,y);
salta(xx, yy);
}
};
void generaKoch(int nivel, double distancia){
if(nivel==0){
tortuga.traza(distancia);
}else{
generaKoch(nivel-1, distancia/3);
tortuga::gira(60.0);
generaKoch(nivel-1, distancia/3);
tortuga::gira(-120.0);
generaKoch(nivel-1, distancia/3);
tortuga:gira(60);
generaKoch(nivel-1, distancia/3);
}
}
void main()
{
int gdriver = DETECT, gmode,n=6;
double d=50;
initgraph(&gdriver, &gmode, "c:\\tc\\bgi");
generaKoch(n,d);
system("pause");
closegraph();
}
aunque tambien trabaje este funcion la proimera no estoy seguro si funciona no la he probado aun
void f(double x1,double y1,double D,double ang)
{
double x,y;
D=0;
do
{
x=x1 + cos(ang)*D;
y=y1 - sin(ang)*D;
putpixel(x,y,14);
D=D+0.005;
}while(D<=100);
}
-
esta otra funcion avanzar es mucho mas rapida solo reemplace la funcion putpixel(x,y14) por la funcion line
void f(double x1,double y1,double ang,double d1)
{
double x,y;
d1=100;
x=x1 + cos(ang)*d1;
y=y1 + sin(ang)*d1;
setcolor(14);
line(x1,y1,x,y);
}
-
funcion inciar curva de koch algoritmo
Iniciar_Koch( Punto_Inicial, Longitud, Número_Iteraciones )
1. Declarar: Cursor como un punto y un ángulo
2. Inicializar Cursor:
3. Cursor.punto ← Punto_Inicial
4. Cursor.ángulo ← 0
5. Dibujar_Koch( Cursor, Longitud, Número_Iteraciones )
6. Terminar
void koch()
{
float x ,y,lon,tet ;
int n_i;
x=100;
y=200;
tet=0;
dibujar_koch(x,y,lon,n_i,ang);
}
-
bueno creo logre encontrar una en la web un codigo que dibuja el copo de koch me sera muy util para empezar a dibujar otro tipos de figuras co0n funciones recursivas
-
/*El siguiente programa ha sido probado y testeado bajo MS-DOS*/
/*Programado en Borland C++ 5.0*/
/*Grafica el Fractal de Von Koch en forma recursiva.*/
#include <stdio.h>
#include <conio.h>
#include <graphics.h>
#include <math.h>
#define PI 3.14159
/************************Funciones*****************/
/*Dibuja una linea de longitud r y angulo angulo*/
void draw(double r,double angulo);
/*Simplemente arma el denominado copo de Koch */
void copoKoch(int orden, double r);
/*Grafica la curva de Von Koch en forma recursiva como es de esperarse*/
void koch(int orden,double r,double angulo);
/*Inicia el modo grafico*/
int iniModoGrafico(int *X_max, int *Y_max);
/****************************************************/
int
main(void)
{
int Xm,Ym;
float lado; /*Longitud de cada lado de */
int orden; /*Indica el orden del fractal.Orden 0 es el caso Base*/
printf("Ingrese el orden: ");
scanf("%d",&orden);
printf("Ingrese el lado: ");
scanf("%f",&lado);
iniModoGrafico(&Xm,&Ym);
moveto( ((Xm+1)/2)-(Xm+1)/4,((Ym+1) /2)+(Ym+1)/4);
copoKoch(orden,lado);
getch();
closegraph();
return 0;
}
/**************************/
void copoKoch(int orden, double r)
{
koch(orden,r,PI/3);
koch(orden,r,-PI/3);
koch(orden,r,PI);
}
/**************************/
void draw(double r,double angulo)
{
linerel(r*cos(angulo), -r*sin (angulo));
}
/*********************************/
int iniModoGrafico(int *X_max, int *Y_max)
{
int controlador = DETECT, modo, numerror;
initgraph(&controlador, &modo, "C:\\BC5\\BGI");
numerror = graphresult(); /*Si queres podes usar numerror*/
if (numerror != grOk) /* grOk vale 0 si no hay error */
return numerror;
*X_max = getmaxx();
*Y_max = getmaxy();
return 0;
}
/**************************/
void koch(int orden,double r,double angulo)
{
if(orden==0)
draw(r,angulo);
else
{
koch(orden-1,r/3,angulo);
koch(orden-1,r/3,angulo+(PI/3));
koch(orden-1,r/3,angulo-(PI/3));
koch(orden-1,r/3,angulo);
}
}
/**************************/