génération d'une fractale (mandelbrot ou julia)
avec un assez grand zoom possible pour se plonger dans l'infinité !!
Réalisé avec la librairie FOX Toolkit.
Source / Exemple :
/********************************************************************************
- *
- FrAcTaL *
- *
- FrAcTaL is a Mandelbrot and Julia fractals generator, and navigator. *
- *
- Copyright (C) 2004-2005 Julien MICHOT *
- *
- Contact : m.i.t.c.h@free.fr - http://www.webfractales.com *
- *
- This program 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
- *
- *
- You can have the Fox-Toolkit library here : www.fox-toolkit.org *
- *
#include "fx.h"
#define TAILLEX 800
#define TAILLEY 600
#define TAILLEMINX 100
#define TAILLEMINY 75
#define pi 3.1415926535897932384626433832
FXuchar ImageFrac[TAILLEX*TAILLEX*3]; // Created images
FXuchar ImageFrac2[TAILLEMINX*TAILLEMINX*3]; // Created images
double Val[TAILLEX*TAILLEY];
double Val2[TAILLEMINX*TAILLEMINY];
// Event Handler Object
class Fractal : public FXMainWindow {
// Macro for class hierarchy declarations
FXDECLARE(Fractal)
private:
FXCanvas *canvas; // Canvas to draw into
FXImage *Frac;
FXBMPImage *picture; // Complete picture
FXCanvas *canvas2;
FXImage *Frac2;
FXBMPImage *picture2;
FXFont *font; // Font for text
FXLabel * InfosCoor;
FXLabel * InfosCoor2;
FXCursor * cur;
FXCheckButton * EnJulia, * JuliaAuto;
FXCursor * cursorautre;
FXTextField * JuliaX, * JuliaY;
double ConstJuliaX,ConstJuliaY;
FXDial * x_dial;
FXMDIClient *mdiclient; // MDI Client area
double echelle;
int taillex,tailley;
double bail_min;//, bail_max
int i,j,la,ha;
double ax,ay,bx,by,bxx,norme;
double Echel,Echel2,X0,Y0,Xtmp,Ytmp;
bool Z1ok,Z2ok,Ok;
int EtatZoom,QuelZoom;
int CoordZX,CoordZY,CoordZX3,CoordZY3,CoordZX2,CoordZY2,p1av,p2av,larg,haut,IsMove;
int CurX,CurY;
int color_frac;
protected:
Fractal(){}
public:
// Message handlers
long onCanvasRepaint(FXObject*,FXSelector,void*);
long onCanvasRepaint2(FXObject*,FXSelector,void*);
long onCmdWell(FXObject*,FXSelector,void*);
long onCmdWell2(FXObject*,FXSelector,void*);
long onCmdRestore(FXObject*,FXSelector,void*);
long onMouseDown(FXObject*,FXSelector,void * ptr);
long onMouseDown2(FXObject*,FXSelector,void * ptr);
long onMouseUp(FXObject*,FXSelector,void * ptr);
long onMouseUp2(FXObject*,FXSelector,void * ptr);
long onMouseMove(FXObject*,FXSelector,void * ptr);
long onCmdAbout(FXObject*,FXSelector,void * ptr);
long onMouseWheel(FXObject*,FXSelector,void*);
long onKeyPress(FXObject*,FXSelector,void*);
long onJulia(FXObject*,FXSelector,void*);
long onReset(FXObject*,FXSelector,void*);
long onLeftBtnPress(FXObject*,FXSelector,void*);
public:
// Messages for our class
enum{
ID_CANVAS=FXMainWindow::ID_LAST,
ID_CANVAS2,
ID_JULIA,
ID_JULIAAUTO,
ID_RESTORE,
ID_ABOUT,
ID_ROLL,
ID_DIAL_X,
ID_RESET,
ID_LAST
};
public:
// Fractal constructor
Fractal(FXApp* a);
// Initialize
virtual void create();
void MakeFrac(int Num);
void Init(int Num);
void ColorFrac(int Num, bool uok);
void RefreshMin(int nblarg);
void RefreshImg(int Num);
// Fractal destructor
virtual ~Fractal();
};
// Message Map for the Scribble App class
FXDEFMAP(Fractal) FractalMap[]={
//____Message_Type______________ID_______________Message_Handler___
FXMAPFUNC(SEL_PAINT, Fractal::ID_CANVAS, Fractal::onCanvasRepaint),/*
FXMAPFUNC(SEL_COMMAND, Fractal::ID_WELL, Fractal::onCmdWell),*/
FXMAPFUNC(SEL_PAINT, Fractal::ID_CANVAS2, Fractal::onCanvasRepaint2),
FXMAPFUNC(SEL_LEFTBUTTONPRESS, Fractal::ID_CANVAS, Fractal::onMouseDown),
FXMAPFUNC(SEL_LEFTBUTTONRELEASE, Fractal::ID_CANVAS, Fractal::onMouseUp),
FXMAPFUNC(SEL_RIGHTBUTTONPRESS, Fractal::ID_CANVAS, Fractal::onMouseDown2),
FXMAPFUNC(SEL_RIGHTBUTTONRELEASE, Fractal::ID_CANVAS, Fractal::onMouseUp2),
FXMAPFUNC(SEL_MOTION, Fractal::ID_CANVAS, Fractal::onMouseMove),
FXMAPFUNC(SEL_MOUSEWHEEL, Fractal::ID_CANVAS, Fractal::onMouseWheel),
FXMAPFUNC(SEL_COMMAND, Fractal::ID_RESTORE, Fractal::onCmdRestore),
FXMAPFUNC(SEL_KEYPRESS, Fractal::ID_CANVAS, Fractal::onKeyPress),
FXMAPFUNC(SEL_COMMAND, Fractal::ID_ABOUT, Fractal::onCmdAbout),
FXMAPFUNC(SEL_COMMAND, Fractal::ID_JULIA, Fractal::onJulia),
FXMAPFUNC(SEL_COMMAND, Fractal::ID_RESET, Fractal::onReset),
FXMAPFUNC(SEL_CHANGED, Fractal::ID_DIAL_X, Fractal::onLeftBtnPress),
};
// Macro for the ScribbleApp class hierarchy implementation
FXIMPLEMENT(Fractal,FXMainWindow,FractalMap,ARRAYNUMBER(FractalMap))
// Construct Fractal
Fractal::Fractal(FXApp* a):FXMainWindow(a,"Fractals",NULL,NULL,DECOR_ALL,0,0,TAILLEX+150,TAILLEY+80){
FXVerticalFrame *canvasFrame;
FXVerticalFrame *buttonFrame;
FXHorizontalFrame *contents;
FXColorDialog *colordlg=new FXColorDialog(this,"Color Dialog");
contents=new FXHorizontalFrame(this,LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y,0,0,0,0, 0,0,0,0);
// LEFT pane to contain the canvas
canvasFrame=new FXVerticalFrame(contents,FRAME_SUNKEN|LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT,0,0,0,0,10,10,10,10);
// Label above the canvas
new FXLabel(canvasFrame,"FrAcTal 0.1, by MiTcH",NULL,JUSTIFY_CENTER_X|LAYOUT_FILL_X);
// Horizontal divider line
new FXHorizontalSeparator(canvasFrame,SEPARATOR_GROOVE|LAYOUT_FILL_X);
// Drawing canvas
canvas=new FXCanvas(canvasFrame,this,ID_CANVAS,FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT);
// RIGHT pane for the buttons
buttonFrame=new FXVerticalFrame(contents,FRAME_SUNKEN|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT,0,0,0,0,10,10,10,10);
// Label above the buttons
// new FXLabel(buttonFrame,"Button Frame",NULL,JUSTIFY_CENTER_X|LAYOUT_FILL_X);
// Horizontal divider line
new FXHorizontalSeparator(buttonFrame,SEPARATOR_RIDGE|LAYOUT_FILL_X);
// Button to draw
new FXButton(buttonFrame,"Save Image...\tRead back image and save to file",NULL,this,ID_RESTORE,FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT,0,0,0,0,10,10,5,5);
EnJulia = new FXCheckButton(buttonFrame,"Julia",this,ID_JULIA);
JuliaX = new FXTextField(buttonFrame,1,NULL,0,FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FIX_WIDTH,0,0,90,0);
JuliaY = new FXTextField(buttonFrame,1,NULL,0,FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FIX_WIDTH,0,0,90,0);
JuliaAuto = new FXCheckButton(buttonFrame,"selection auto",this,ID_JULIAAUTO);
FXString ch="";
for(int i=0;i<=(4.0*TAILLEY/100.0);i++)
;// ch+="\n";
canvas2=new FXCanvas(buttonFrame,this,ID_CANVAS2,FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT,0,0,100,75);
new FXLabel(buttonFrame,ch,NULL,JUSTIFY_CENTER_X|LAYOUT_FILL_X);
// Create images with dithering
Frac=new FXImage(getApp(),ImageFrac,IMAGE_DITHER|IMAGE_SHMI|IMAGE_SHMP,TAILLEX,TAILLEY);
Frac2=new FXImage(getApp(),ImageFrac2,IMAGE_DITHER|IMAGE_SHMI|IMAGE_SHMP,TAILLEMINX,TAILLEMINY);
// Create image with nearest color instead of dithering
// Result image
picture=new FXBMPImage(getApp(),NULL,IMAGE_SHMI|IMAGE_SHMP,TAILLEX,TAILLEY);
picture2=new FXBMPImage(getApp(),NULL,IMAGE_SHMI|IMAGE_SHMP,TAILLEMINX,TAILLEMINY);
//picture=new FXBMPImage(getApp(),NULL,0,850,TAILLEY);
// mdiclient=new FXMDIClient(buttonFrame,LAYOUT_FILL_X|LAYOUT_FILL_Y);
FXMatrix *colori=new FXMatrix(buttonFrame,1,FRAME_THICK|FRAME_RAISED|MATRIX_BY_COLUMNS|LAYOUT_TOP|LAYOUT_LEFT,0,0,0,0,10,10,10,10);
new FXLabel(colori,"COULEUR",NULL,JUSTIFY_CENTER_X|LAYOUT_FILL_X);
x_dial=new FXDial(colori,NULL,ID_DIAL_X,FRAME_SUNKEN|FRAME_THICK|DIAL_CYCLIC|DIAL_HORIZONTAL|LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT|LAYOUT_CENTER_Y,0,0,90,14,0,0,0,0);
x_dial->setTipText("Changer la couleur");
//x_dial->setNotchOffset(900);
x_dial->setRange(0,255);
x_dial->setValue(255);
new FXButton(buttonFrame,"E&xit\tQuitter FrAcTaL",NULL,getApp(),FXApp::ID_QUIT,FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_BOTTOM|LAYOUT_LEFT,0,0,0,0,10,10,5,5);
new FXButton(buttonFrame,"A&bout\tA propos du logiciel...",NULL,this,ID_ABOUT,FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_BOTTOM|LAYOUT_LEFT,0,0,0,0,10,10,5,5);
new FXButton(buttonFrame,"&Reset\tRevenir au mandelbrot",NULL,this,ID_RESET,FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_BOTTOM|LAYOUT_LEFT,0,0,0,0,10,10,5,5);
// Init(1);
bail_min=0.003;
Echel=0.005*(800/TAILLEX);
Echel2=0.005*(800/TAILLEMINX);
X0=(double) -2.1;
Y0=(double) 1.3;
Z1ok=0;Z2ok=0;Ok=0;
larg=0;
EtatZoom=0;
QuelZoom=1;
color_frac=255;
MakeFrac(1);
MakeFrac(2);
// Make font
font=new FXFont(getApp(),"Comic sans MS",15,FONTWEIGHT_BOLD);
new FXHorizontalSeparator(canvasFrame,SEPARATOR_GROOVE|LAYOUT_FILL_X);
cursorautre= new FXCursor(getApp(),CURSOR_IBEAM);
cursorautre->create();
InfosCoor = new FXLabel(canvasFrame,"0 x 0",NULL,JUSTIFY_BOTTOM|LAYOUT_FILL_X);
InfosCoor2 = new FXLabel(canvasFrame," ",NULL,JUSTIFY_BOTTOM|LAYOUT_FILL_X);
// Make a tip
new FXTooltip(getApp());
cur= new FXCursor(getApp(),CURSOR_IBEAM);
setDragCursor(cur);
}
// Destroy Fractal
Fractal::~Fractal(){
delete Frac;
delete picture;
delete Frac2;
delete picture2;
delete font;
}
// Create and initialize
void Fractal::create(){
// Create the windows
FXMainWindow::create();
// Create images
Frac->create();
Frac2->create();
picture->create();
picture2->create();
// Font too
font->create();
// Make it appear
show(PLACEMENT_SCREEN);
// First time repaint
canvas->update();
canvas2->update();
}
// Handle the clear message
long Fractal::onCanvasRepaint(FXObject*,FXSelector,void* ptr){
FXEvent *event=(FXEvent*)ptr;
FXuint pat;
// We caused a redraw, so redo it all
if(event->synthetic){
FXDCWindow dc(picture);
// Erase the canvas, color comes from well
dc.setForeground(0);
dc.fillRectangle(0,0,picture->getWidth(),picture->getHeight());
// Draw images
dc.drawImage(Frac,0,0);
dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut); ////
}
// Now repaint the screen
FXDCWindow sdc(canvas,event);
// Clear whole thing
sdc.setForeground(0);
sdc.fillRectangle(0,0,canvas->getWidth(),canvas->getHeight());
// Paint image
sdc.drawImage(picture,0,0);
return 1;
}
long Fractal::onCanvasRepaint2(FXObject*,FXSelector,void* ptr){
FXEvent *event2=(FXEvent*)ptr;
FXuint pat2;
// We caused a redraw, so redo it all
if(event2->synthetic){
FXDCWindow dc2(picture2);
// Erase the canvas, color comes from well
dc2.setForeground(0);
dc2.fillRectangle(0,0,picture2->getWidth(),picture2->getHeight());
// Draw images
dc2.drawImage(Frac2,0,0);
/*
Init();
for(i=0;i<la;i++)
for(j=0;j<ha;j++)
{
ax= (double) (i-Xcenter)/Zoom;
ay= (double) (j-Ycenter)/Zoom;
for(int u=0;u<=100&&norme>bail_min;u++)
{
bxx=bx;
bx=(double)bx*bx-(double)by*by + ax;
by=(double) 2.0*bxx*by + ay;
norme=sqrt(bx*bx+by*by);
}
dc.setForeground(FXRGB(255,255*norme,0));
dc.fillRectangle(i,j,1,1);
ax=0;ay=0;bx=0;by=0;norme=1;
}
// Draw text
// dc2.setTextFont(font);
// dc2.setForeground(FXRGB(150,0,150));
// dc2.drawText(TAILLEY,550,"Julien Michot",13);
}
// Now repaint the screen
FXDCWindow sdc2(canvas2,event2);
// Clear whole thing
sdc2.setForeground(FXRGB(212,208,200));
sdc2.fillRectangle(0,0,canvas2->getWidth(),canvas2->getHeight());
// Paint image
sdc2.drawImage(picture2,0,0);
return 1;
}
// Color well got changed
long Fractal::onCmdWell(FXObject*,FXSelector,void*)
{
canvas->update();
return 1;
}
// Color well got changed
long Fractal::onCmdWell2(FXObject*,FXSelector,void*)
{
canvas2->update();
return 1;
}
// Restore image from off-screen pixmap
long Fractal::onCmdRestore(FXObject*,FXSelector,void*){
canvas->update();
FXFileDialog savedialog(this,"Save BMP");
savedialog.setDirectory(".");
if(savedialog.execute()){
FXFileStream outfile;
if(outfile.open(savedialog.getFilename(),FXStreamSave)){
picture->restore();
picture->savePixels(outfile);
outfile.close();
}
}
return 1;
}
// Here we begin
int main(int argc,char *argv[]){
// Make application
FXApp application("Image","FoxText");
// Start app
application.init(argc,argv);
// Make window
new Fractal(&application);
// Create the application's windows
application.create();
// Run the application
return application.run();
}
void Fractal::MakeFrac(int Num)
{
color_frac=x_dial->getValue();
Init(Num);
bool uok;
for(i=0;i<la;i++)
{
for(j=0;j<ha;j++)
{
uok=1;
ax= (double) (i*echelle+Xtmp);
ay= (double) (j*echelle-Ytmp);
if(EnJulia->getCheck())
{
bx=ax;
by=ay;
}
for(int u=0;u<=100&&norme>bail_min && norme<=300000000000;u++)//300000000000
{
bxx=bx;
if(!(EnJulia->getCheck()))
{
bx=(double)bx*bx-(double)by*by + ax;
by=(double) 2.0*bxx*by + ay;
}else{
bx=(double)bx*bx-(double)by*by + ConstJuliaX;//Xtmp;
by=(double) 2.0*bxx*by + ConstJuliaY;//Ytmp;
}
norme= (double) sqrt((double)bx*bx+(double)by*by);
uok=u;
}
if(Num==1) Val[(j*taillex+i)]=norme;
else if(Num==2) Val2[(j*taillex+i)]=norme;
ColorFrac(Num,uok);
ax=0;ay=0;bx=0;by=0;norme=1;
}
}
}
void Fractal::RefreshImg(int Num)
{
FXDCWindow dc(canvas);
FXDCWindow dc2(canvas2);
if(Num==1)
{
delete Frac;
Frac=new FXImage(getApp(),ImageFrac,IMAGE_DITHER|IMAGE_SHMI|IMAGE_SHMP,TAILLEX,TAILLEY);
Frac->create();
dc.setForeground(FXRGB(0,0,0));
dc.fillRectangle(0,0,TAILLEX,TAILLEY);
dc.drawImage(Frac,0,0);
}else{
delete Frac2;
Frac2=new FXImage(getApp(),ImageFrac2,IMAGE_DITHER|IMAGE_SHMI|IMAGE_SHMP,TAILLEMINX,TAILLEMINY);
Frac2->create();
dc2.setForeground(FXRGB(0,0,0));
dc2.fillRectangle(0,0,TAILLEX,TAILLEY);
dc2.drawImage(Frac2,0,0);
}
}
void Fractal::ColorFrac(int Num, bool uok)
{
if(norme<2)
{ // à l'intérieur
if(Num==1)
{
ImageFrac[3*(j*taillex+i)]=0;
ImageFrac[3*(j*taillex+i)+1]=0;
ImageFrac[3*(j*taillex+i)+2]=255*sin(norme);
}else{
ImageFrac2[3*(j*taillex+i)]=0;
ImageFrac2[3*(j*taillex+i)+1]=0;
ImageFrac2[3*(j*taillex+i)+2]=255*sin(norme);
}
}else{// à l'extérieur
if(!(j==0 && i==0))
if(Num==1)
{
ImageFrac[3*(j*taillex+i)]=color_frac*(sin(norme/Val[j*taillex+i-1]));
ImageFrac[3*(j*taillex+i)+1]=color_frac*(sin(norme/Val[j*taillex+i-1]));
ImageFrac[3*(j*taillex+i)+2]=color_frac*(sin(norme/Val[j*taillex+i-1]));
}else{
ImageFrac2[3*(j*taillex+i)]=color_frac*(sin(norme/Val2[j*taillex+i-1]));
ImageFrac2[3*(j*taillex+i)+1]=color_frac*(sin(norme/Val2[j*taillex+i-1]));
ImageFrac2[3*(j*taillex+i)+2]=color_frac*(sin(norme/Val2[j*taillex+i-1]));
}
}
/*
if(norme<=bail_min )
{
if(Num==1)
{
ImageFrac[3*(j*taillex+i)]=255;
ImageFrac[3*(j*taillex+i)+1]=0;//(255-255.0*((double)bail_min/norme));
ImageFrac[3*(j*taillex+i)+2]=0;
}else{
ImageFrac2[3*(j*taillex+i)]=255;
ImageFrac2[3*(j*taillex+i)+1]=(255-255.0*((double)bail_min/norme));
ImageFrac2[3*(j*taillex+i)+2]=0;
}
// if(norme >0.001) ImageFrac[3*(j*TAILLEX+i)+2]=255;
// ImageFrac[3*(j*TAILLEX+i)+2]=255-100*sqrt(ax*ax+ay*ay);
// if((double) sqrt((double)ax*ax+(double)ay*ay) == 0) ImageFrac[3*(j*TAILLEX+i)+1]=255;
} else {
if(Num==1)
{
ImageFrac[3*(j*taillex+i)]=0;
ImageFrac[3*(j*taillex+i)+1]=0;
ImageFrac[3*(j*taillex+i)+2]=255*sin(norme);
}else{
ImageFrac2[3*(j*taillex+i)]=255*sin(((int)(norme)%255)-2.0*pi/3.0);
ImageFrac2[3*(j*taillex+i)+1]=255*sin(((int)(norme)%255)-pi/3.0);
ImageFrac2[3*(j*taillex+i)+2]=255*sin(((int)(norme)%255));
}
}
if(0)
{
if(Num==1)
{
ImageFrac[3*(j*taillex+i)]=0;
ImageFrac[3*(j*taillex+i)+1]=0;
ImageFrac[3*(j*taillex+i)+2]=0;
}else{
ImageFrac2[3*(j*taillex+i)]=255;
ImageFrac2[3*(j*taillex+i)+1]=(255-255.0*((double)bail_min/norme));
ImageFrac2[3*(j*taillex+i)+2]=0;
}
// if(norme >0.001) ImageFrac[3*(j*TAILLEX+i)+2]=255;
// ImageFrac[3*(j*TAILLEX+i)+2]=255-100*sqrt(ax*ax+ay*ay);
// if((double) sqrt((double)ax*ax+(double)ay*ay) == 0) ImageFrac[3*(j*TAILLEX+i)+1]=255;
} else {
if(Num==1)
{
ImageFrac[3*(j*taillex+i)]=uok;
ImageFrac[3*(j*taillex+i)+1]=uok;
ImageFrac[3*(j*taillex+i)+2]=uok;
}else{
ImageFrac2[3*(j*taillex+i)]=255*sin(((int)(norme)%255)-2.0*pi/3.0);
ImageFrac2[3*(j*taillex+i)+1]=255*sin(((int)(norme)%255)-pi/3.0);
ImageFrac2[3*(j*taillex+i)+2]=255*sin(((int)(norme)%255));
}
}*/
}
void Fractal::Init(int Num)
{
if(Num==1)
{
Xtmp=X0;
Ytmp=Y0;
echelle=Echel;
taillex=TAILLEX;
tailley=TAILLEY;
}else{
echelle=Echel2;
taillex=TAILLEMINX;
tailley=TAILLEMINY;
}
la=taillex;ha=tailley;
ax=0;ay=0;bx=0;by=0;norme=1;
}
long Fractal::onMouseDown(FXObject*,FXSelector,void * ptr)
{
FXEvent * ev = (FXEvent *) ptr;
FXDCWindow dc(canvas);
if(!(JuliaAuto->getCheck()))
{
switch(EtatZoom)
{
case 0:
CoordZX=ev->win_x;
CoordZY=ev->win_y;
CoordZX2=CoordZX;
CoordZY2=CoordZY;
CoordZX3=0;
CoordZX3=0;
Z1ok=1;
p1av=0;p2av=0;
EtatZoom=1;
break;
case 1:
break;
case 4:
CoordZX=CoordZX2;
CoordZY=CoordZY2;
if(QuelZoom==1||1)
{
X0+=(double)CoordZX2*Echel;
Y0-=(double)CoordZY2*Echel;
}else{
X0-=(double)(CoordZX2)*Echel/2.0;
Y0+=(double)(CoordZY2)*Echel/2.0;
}
if(larg==0) larg=20;
if(QuelZoom==1)
Echel*=(double)((double)(larg)/TAILLEX);
else
Echel*=(double)((double)TAILLEX/(larg));
MakeFrac(1);
RefreshImg(1);
EtatZoom=0;
QuelZoom=1;
break;
case 3:
CoordZX3=ev->win_x;
CoordZY3=ev->win_y;
IsMove=0;
if( ev->win_x >= FXMIN(CoordZX,CoordZX2)
&& ev->win_x <= FXMAX(CoordZX,CoordZX2)
&& ev->win_y >= FXMIN(CoordZY,CoordZY2)
&& ev->win_y <= FXMAX(CoordZY,CoordZY2)
) EtatZoom=4;
else
{
if(echelle!=Echel) dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);
EtatZoom=0;
}
//dc.drawFocusRectangle(CoordZX,CoordZY,p1av,p2av);
dc.drawFocusRectangle(CoordZX,CoordZY,larg,haut);
dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);
break;
case 5:
CoordZX3=ev->win_x;
CoordZY3=ev->win_y;
CoordZX=CoordZX2;
CoordZY=CoordZY2;
IsMove=0;
if( ev->win_x >= FXMIN(CoordZX2,CoordZX2+larg)
&& ev->win_x <= FXMAX(CoordZX2,CoordZX2+larg)
&& ev->win_y >= FXMIN(CoordZY2,CoordZY2+haut)
&& ev->win_y <= FXMAX(CoordZY2,CoordZY2+haut)
) EtatZoom=4;
else
{
dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);
EtatZoom=0;
QuelZoom=1;
}
//dc.drawFocusRectangle(CoordZX,CoordZY,p1av,p2av);
// dc.drawFocusRectangle(CoordZX,CoordZY,larg,haut);
// dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);
break;
default:
EtatZoom=0;
QuelZoom=1;
break;
}
/*
if(!Z2ok)
{
FXEvent * ev = (FXEvent *) ptr;
CoordZX=ev->win_x;
CoordZY=ev->win_y;
Z1ok=1;
p1av=0;p2av=0;
}else{
}
}else{
MakeFrac(1);
RefreshImg(1);
JuliaAuto->setCheck(0);
}
return 1;
}
long Fractal::onMouseDown2(FXObject* z,FXSelector zz,void * ptr)
{//
QuelZoom=-1;
onMouseDown(z,zz,ptr);
/*
if(!Z1ok)
{
FXEvent * ev = (FXEvent *) ptr;
CoordZX=ev->win_x;
CoordZY=ev->win_y;
Z2ok=1;
p1av=0;p2av=0;
}else{
}*/
return 1;
}
long Fractal::onMouseUp(FXObject*,FXSelector,void * ptr)
{
FXEvent * ev = (FXEvent *) ptr;
switch(EtatZoom)
{
case 1:
CoordZX2=ev->win_x;
CoordZY2=ev->win_y;
EtatZoom=3;
break;
case 4:
if(IsMove==0)
{
CoordZX=CoordZX2;
CoordZY=CoordZY2;
X0+=(double)CoordZX*Echel;
Y0-=(double)CoordZY*Echel;
if(larg==0) larg=20;
if(QuelZoom==1)
Echel*=(double)((double)(larg)/TAILLEX);
else
Echel*=(double)((double)TAILLEX/(larg));
MakeFrac(1);
RefreshImg(1);
QuelZoom=1;
EtatZoom=0;
}else EtatZoom=5;
break;
default:
QuelZoom=1;
break;
}
return 1;
}
long Fractal::onMouseUp2(FXObject* z,FXSelector zz,void * ptr)
{
onMouseUp(z,zz,ptr);
return 1;
}
long Fractal::onMouseWheel(FXObject* z,FXSelector,void* ptr)
{
FXEvent * ev = (FXEvent *) ptr;
FXString Chain;
if(QuelZoom==1 && ( (ev->code)==65507 || (ev->code)==16777215))
QuelZoom=-1;
else if(QuelZoom==-1 && (ev->code)!=65507 && (ev->code)!=16777215 )
{
QuelZoom=1;
}
FXint x,y;
FXuint ze=0;
this->getCursorPosition(x,y,ze);
Chain= FXStringVal((ze),10)+"-"+FXStringVal((QuelZoom),10);
InfosCoor2->setText(Chain);
larg=(TAILLEX/2);
if(ze==16)
{
X0+=(double)(CurX)*Echel/2.0;
Y0-=(double)(CurY)*Echel/2.0;
Echel*=(double)((double)(larg)/TAILLEX);
}else{
Echel*=(double)((double)TAILLEX/(larg));
X0-=(double)(CurX)*Echel/2.0;
Y0+=(double)(CurY)*Echel/2.0;
}
MakeFrac(1);
RefreshImg(1);
QuelZoom=1;
EtatZoom=0;
return 1;
}
long Fractal::onKeyPress(FXObject* z,FXSelector zz,void* ptr)
{
FXEvent * ev = (FXEvent *) ptr;
FXString Chain = " key="+ FXStringVal(ev->code,10);
InfosCoor2->setText(Chain);
FXDCWindow dc(canvas);
switch(ev->code)
{
case 65421://enter
EtatZoom=4;
IsMove=0;
onMouseUp(z,zz,ptr);
break;
case 65293://enter
EtatZoom=4;
IsMove=0;
onMouseUp(z,zz,ptr);
break;
case 65307://echap
if(EtatZoom==5 || EtatZoom==3)
{
if( EtatZoom!=3 ) dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);
else if(echelle!=Echel) dc.drawFocusRectangle(CoordZX,CoordZY,larg,haut);
EtatZoom=0;
QuelZoom=1;
}
break;
default:
break;
}
return 1;
}
long Fractal::onMouseMove(FXObject*,FXSelector,void * ptr)
{
int p1,p2;
FXString Chain;
IsMove=0;
FXEvent * ev = (FXEvent *) ptr;
CurX=ev->win_x;
CurY=ev->win_y;
if(ev->win_y < TAILLEY && ev->win_x < TAILLEX)
{
Chain= FXStringVal((float)(ev->win_x)*Echel+X0,4,0) + " x " + FXStringVal((float)Y0-(ev->win_y)*Echel,4,0) + " norme="+ FXStringVal((float)(Val[(ev->win_y)*TAILLEX + ev->win_x]/Val[(ev->win_y)*TAILLEX + ev->win_x-1]),10,0);
InfosCoor->setText(Chain);
}
FXDCWindow dc(canvas);
switch(EtatZoom)
{
case 1:
if(ev->win_y < TAILLEY && ev->win_x < TAILLEX)
{
if( ev->win_y >= (CoordZX+(ev->win_x-CoordZX)*TAILLEY/TAILLEX) && ev->win_x <= (CoordZY+(ev->win_y-CoordZY)*TAILLEX/TAILLEY) )
{
p1=((ev->win_y-CoordZY)*TAILLEX/TAILLEY);
p2=ev->win_y-CoordZY;
}else if(ev->win_x >= (CoordZY+(ev->win_y-CoordZY)*TAILLEX/TAILLEY) && ev->win_y >= (CoordZX+(ev->win_x-CoordZX)*TAILLEY/TAILLEX)) {
p2=((ev->win_x-CoordZX)*TAILLEY/TAILLEX);
p1=ev->win_x-CoordZX;
}else {
p2=((ev->win_x-CoordZX)*TAILLEY/TAILLEX);
p1=ev->win_x-CoordZX;
} //canvas->update();
if(abs(p1)>=1 && abs(p2)>=1) dc.drawFocusRectangle(CoordZX,CoordZY,p1av,p2av);
dc.drawFocusRectangle(CoordZX,CoordZY,p1,p2);
larg=p1;
haut=p2;
p1av=p1;p2av=p2;
RefreshMin(ev->win_x-CoordZX);
}
break;
case 4:
dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);
CoordZX2=CoordZX+(ev->win_x-CoordZX3);
CoordZY2=CoordZY+(ev->win_y-CoordZY3);
dc.drawFocusRectangle(CoordZX2,CoordZY2,larg,haut);
p1av=ev->win_x;p2av=ev->win_y;
IsMove=1;
RefreshMin(larg);
break;
default:
if(EnJulia->getCheck() && JuliaAuto->getCheck())
{
ConstJuliaX=X0+(double)(ev->win_x)*Echel;
ConstJuliaY=Y0-(double)(ev->win_y)*Echel;
JuliaX->setText("x="+FXStringVal(ConstJuliaX));
JuliaY->setText("y="+FXStringVal(ConstJuliaY));
if(larg==0) larg=TAILLEX;
RefreshMin(larg);
}
break;
}
return 1;
}
long Fractal::onCmdAbout(FXObject*,FXSelector,void * ptr)
{
FXMessageBox about(this,"About FrAcTal 0.1","Logiciel de création de fractales\nAuteur : Julien MICHOT\nemail : m.i.t.c.h@free.fr\nsite : www.fractals.fr.fm",NULL,MBOX_OK|DECOR_TITLE|DECOR_BORDER);
about.execute();
return 1;
}
void Fractal::RefreshMin(int nblarg)
{
if(QuelZoom==1)
{
if(!(JuliaAuto->getCheck()))
{
Xtmp=X0+(double)CoordZX2*Echel;
Ytmp=Y0-(double)CoordZY2*Echel;
}else{
}
Echel2=(double)(Echel*(TAILLEX/TAILLEMINX)*(double)(nblarg)/TAILLEX);
}else{
if(!(JuliaAuto->getCheck()))
{
Xtmp=X0+(double)CoordZX2*Echel;
Ytmp=Y0-(double)CoordZY2*Echel;
}
if( (nblarg) !=0)
Echel2=(double)(Echel*(TAILLEX/TAILLEMINX)*(double)TAILLEX/(nblarg));
else Echel2=(double)(Echel*(TAILLEX/TAILLEMINX)*(double)TAILLEX/(20.0));
}
MakeFrac(2);
RefreshImg(2);
}
long Fractal::onJulia(FXObject*,FXSelector,void*)
{
this->setDefaultCursor(cursorautre);
if((!EnJulia->getCheck()) || JuliaX->getText()!="" )
{
MakeFrac(1);
RefreshImg(1);
}
MakeFrac(2);
RefreshImg(2);
return 1;
}
long Fractal::onReset(FXObject*,FXSelector,void*)
{
bail_min=0.003;
Echel=0.005*(800/TAILLEX);
Echel2=0.005*(800/TAILLEMINX);
X0=(double) -2.1;
Y0=(double) 1.3;
Z1ok=0;Z2ok=0;Ok=0;
larg=0;
EtatZoom=0;
QuelZoom=1;
EnJulia->setCheck(0);
JuliaAuto->setCheck(0);
MakeFrac(1);
RefreshImg(1);
return 1;
}
long Fractal::onLeftBtnPress(FXObject*,FXSelector,void*)
{EnJulia->setCheck(1);
MakeFrac(2);
RefreshImg(2);
return 1;
}
Conclusion :
L'exécutable et le zip sont disponibles sur
http://www.webfractales.com
MiTcH - Julien Michot
les liens sont quasiment tous HS ....
- Messages postés
-
14947
- Date d'inscription
- lundi 11 juillet 2005
- Statut
- Modérateur
- Dernière intervention
- 21 janvier 2021
93 > bg62La source a 10 ans et le dernier commentaire 7...
Tu te lances dans l'archéologie? :D
je développe une petite appli graphique en c++ et j'utilise depuis peu la Fos toolkit. Je la trouve trés interressante. J'ai quelques souci avec les méthodes de la classe FXDCWindow.
En effet, parmis les méthodes proposées, il y a la possibilité de dessiner des textes sur un canva par exemple grace aux méthodes suivantes:
virtual void drawText (FXint x, FXint y, const FXchar *string, FXuint length)
virtual void drawImageText (FXint x, FXint y, const FXchar *string, FXuint length)
Dans mes methodes de gestion d'évenement j'ai mis:
FXDCWindows dc(canvas);
dc.drawText(0,0,"essai");
Lorsque j'execute l'application, il plante systematiquement lorsque je fait appel à cet evenement.
Je me demande pourqoi?
Je vois que dans le code "fractal", cette méthode est mise en commentaire.
" // dc2.drawText(TAILLEY,550,"Julien Michot",13);" ligne 395
Y a t il un probleme avec cette méthode?
Merci!
Pour rapel cette bibliothèque permet d'avoir une interface graphique.
Ca gestion est d'une simplicité étonnante, elle est portable sous plusieurs OS, rapide, et légère (pas besoin de dll !)
Voici un tutorial pour bien comprendre et debuter sur cette bibliothèque :
http://khayyam.developpez.com/articles/cpp/fox/
En étudiant ce tutorial et la source présente ici, vous verrez l'envie de programmer avec cette lib ;)
++
mais bon...je l'ai surtout fait pour manipuler la librairie FOX Toolkit, et pour montrer que celle-ci est très facile d'utilisation. Et puis, mon dernier programme de fractale tournait seulement sous DOS alors... il fallait tout de même en faire un autre !
A j'ai oublié de le mettre mais ce programme fonctionne normalement aussi sous Linux etc... et il peut aussi récupérer l'image générée pour l'enregistrer (bmp).
Qu'a-t-il de plus que les autres ?...
et bien je pense que le principal intérêt de ce pgm est le zoom, avec la petite fenêtre d'aperçu, qui permettent de naviger facilement et rapidement dans l'antre de Mandelbrot (et de Julia).
Le code n'est pas vraiment beaucoup commenté, c'est vrai, mais en faite j'ai fait ce pgm pendant mon stage...donc dans mon temps libre...donc rapidement et j'ai privilégié la fonctionnalité...
Le calcule des fractales, et notemment de la fractale de Mandelbrot n'est pas d'une complexité rare...c'est simplement l'étude de la convergence d'une suite imaginaire (coordonnées d'un pixel dans le plan), que l'on colorie suivant cette "variation" limitée.
Pour Mandelbrot, il s'agit de l'étude de la convergence de la fonction ZxZ + C (C étant les coordonnées du pixel dans le plan imaginaire, et, à Z on affecte ZxZ+C).
Pour la fractale de Julia, on fixe C à une valeur (imaginaire aussi).
Voilà, j'espère avoir été clair, et sinon ily a toujours www.fractals.fr.fm :) !
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.