پر كردن يك بيضي

سلام

چطوري مي تونيم كه يك بيضي كشيده شده را با يك رنگ خاص پر كرد كه بيضي به اون رنگ پر شده ديده شود؟

كشيدن بيضي مشكل من نيست فقط مي خوام بدونم چطوري اون را پر كنم من خودم فكر مي كنم كه بايد بيضي هاي متحد المركزي بكشم و اون را پر كنم ولي چطوري درون و خارج بيضي زا تشخيص بدم؟

از كجا بدونم الان تابع putpixel ي كه بكار مي برم داره بيرون بيضي را پر مي كنه يا داخل اون رو

در حقيقت چطوري كد بنويسم كه تابع putpixel فقط درون بيضي بكار بيفته ؟ و نقاط را روشن كنه

لطفا راهنمايي كنيد
مرسي.

الگوريتم‌هاي مختلفي هست براي پر كردن يك شكل
در اين ميان ميتونيد از روش همسايگي استفاده كنيد كه با داشتن يك نقطه درون يك شكل بسته، شروع به پر كردن كنيد و 8 مكان اطراف همين نقطه رو كنكاش كنيد و تابع پر كردن رو بصورت بازگشتي صدا بزنيد.
چون با سر ريز stack مواجع ميشيد پس بايد يه استك هم پياده‌سازي بكنيد.
يك توضيح و اينكه براي پر كردن، با دادن نقطه شروع رنگ‌آميزي اقدام به پر كردن كنيد تا اينكه به رنگي برسيد كه با رنگ اولين نقطه يكسان نباشد

سلام.
ممنون از توضیحات دوستمون.البته زیاد سخت گرفتن! روش پیشنهادی نزدیک به Image Processing بود.
لازم نیست از تابع putpixel استفاده کنین. (اگه حتما باید با putpixel انجام بدین , بگید)
نمیدونم برای رسم یک بیضی از تابع ellipse استفاده کردین یا اینکه خودتون کدی رو برای پیاده سازیش
نوشتین. در هر دوصورت ellipese ی که رسم کردین دو تا شعاع داره. درسته؟ کافیه شما شروع به رسم
ellipse هایی کنین که از مقدار دو شعاع یکی یکی کم میشن تا به صفر برسن. به این صورت ellipse شما
پر میشه. (گرچه میتونین مستقیما از fillellipse استفاده کنین. که مستقیما یک ellipse تو پر رسم میکنه.)
نمونه ی زیر میتونه منظورم رو واضحتر بیان کنه :

کد:

---


 int xR = 100;
 int yR = 30;
 int xcor = 100;
 int ycor = 200;
 while(!kbhit())
 {
  ellipse(xcor,ycor,0,360,xR,yR);
  xR--;
  yR--;
  if ( yR == 0 || xR == 0 )
  {
    xR = 100;
    yR = 30;
  }
}

---

اگه مشکلی بود اطلاع بدین.

كدي رو كه دوستمون آوردند براي پر كردن شكل بصورت دواير متحدالمركز هست. منتها توضيحات من جهت پر كردن هر شكلي قابل پياده‌سازي هست كه نمونه ‌اش رو برات آپلود كردم. اين پروژه مربوط به درس گرافيك كامپيوتري بود كه سالها پيش نوشته بودم و رسم پيكسل هم با توابع و اينتراپت‌هاي اسمبلي انجام شده بود.
بخش پر كردن شكل اينطوري هست:

کد:

---


void fill(int x,int y,int c1)
{
 int c2,n,*x1,*y1,x2,y2;
 int *xt,*yt;
 c2=getpixel(x,y);
// if(x<clipx1 || x>clipx2 || y<clipy1 || y>clipy2)
 //  return;
 xt=&x;yt=&y;
 push(*xt,*yt);
 do
 {
  mousepos();
  if(mb==2)
    {do{}while(pop(xt,yt)!=1);return;}
  pset(*xt,*yt,c1);
  if(getpixel(*xt,*yt-1)!=c1 && getpixel(*xt,*yt-1)==c2) push(*xt,*yt-1);
  if(getpixel(*xt,*yt+1)!=c1 && getpixel(*xt,*yt+1)==c2) push(*xt,*yt+1);
  if(getpixel(*xt-1,*yt)!=c1 && getpixel(*xt-1,*yt)==c2) push(*xt-1,*yt);
  if(getpixel(*xt+1,*yt)!=c1 && getpixel(*xt+1,*yt)==c2) push(*xt+1,*yt);
 }while(pop(xt,yt)!=1);
}

---

[ برای مشاهده لینک ، با نام کاربری خود وارد شوید یا ثبت نام کنید ]

دوباره سلام.
ممنون از کدتون اما من نتونستم بگیرمش. امکان داره جایی دیگه اونرو up کنین؟
ضمنا در نمونه ای که گذاشتین نقش mousepos چیه؟
متاسفانه همونطور که گفتم به کدتون دسترسی ندارم.

سلام
از كاربر someone وpalizesoftware ممنون

جواب كاربر someone براي من راحتر بود ولي چون شعاع ها و نقاط مركزي را از كابر مي گرفتم تغييرش دادم

[HTML]
#include <math.h>
#include <stdio.h>
#include <graphics.h>
#include <stdlib.h>
#include <conio.h>
#include <iostream.h>
void ellipse( float xc , float yc , float rx , float ry )
{
float pi = 4*tan(1);
for (float i = 0 ; i<=2*pi ; i+=0.001)
{
float x = rx*cos(i);
float y = ry*sin(i);
putpixel(x+xc,y+yc,7);
}
}
void main()
{
int gd = DETECT , gm ;initgraph(&gd , &gm , "C:\\Red\\Language\\TC\\BGI");
int errorcode = graphresult();
if ( errorcode != 0)
{
cout<<"graphics error"<<grapherrormsg(errorcode);
getch();
exit(0);
}
float xc,yc,rx,ry;
cout << "enter xc, yc ,rx , ry:";
cin>>xc>>yc>>rx>>ry;
ellipse(xc , yc , rx ,ry);
getch();
closegraph();
}
[/HTML]

اما راه كاربرpalize software بهتره چون به درد هر شكلي مي خوره ولي من تابع mouse.... را در هلپ گشتم پيدا نكردم و در ضمن clipx2 و clipex2 ....... براي چيه هستن؟

اگه كمكم كنيد فكر كنم كه راه خودم بهتر باشه
راه من:

مثلا برنامه طوري باشه(پر كردن يك poligan ) كه نقاطي را از يك كاربر دريافت كنه و شكل ان را رسم كنه و بعد ان را پر كنه اينطوري كه خطوط كشيده شده توسط نقاط را جايي ذخيره كنيم (كه اين كار رو نمي دونم چه طوري انجام بدم) بعد نقاط را يكي يكي روي محور ايكس پيمايش كنه ولي روشن نكنه تا به نقطه اي برسه كه روي يكي از خطوط ذخيره شده صدق كنه از اين به بعد نقاط را روشن كنه تا اينكه به خط بعدي برسه از اين به بعد دوباره فقط پيمايش كنه و روشن نكنه

ولي نمي دونم چطوري پياده كنم
لطفا راهنمايي كنيد
مرسي

سلام
كل كد رو اينجا ميذارم:

کد:

---

#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>
typedef struct stk
{
 int x;
 int y;
 struct stk *r,*l;
}STACK;
STACK *front;
//-------------------------------GLOBAL VARIABLE------------------------------
char Eraser[16][33]={"0000011111111110000000",
                    "0001100000000001100000",
                    "0110000000000000011000",
                    "0100000000000000001100",
                    "0110000000000000011100",
                    "0111100000000001111100",
                    "0111111111111111111000",
                    "0011111111111111111000",
                    "0011111111111111111000",
                    "0011111111111111111000",
                    "0001111111111111110000",
                    "0000111111111111110000",
                    "0000111111111111100000",
                    "0000011111111111000000",
                    "0000001111111110000000",
                    "0000000011111100000000"};

char Filler[16][33]={"0000000000000000000000",
                    "0000000000000000000000",
                    "0000000000011111111000",
                    "0000011111100000000110",
                    "0000111111000000000010",
                    "0001111111100000000110",
                    "0001111111111111111010",
                    "0001110011111110111010",
                    "0000100011111101110110",
                    "0000000011111110101010",
                    "0000000011111101011110",
                    "0000000011111110101010",
                    "0000000011111101010110",
                    "0000000011111111101010",
                    "0000000011111101010110",
                    "0000000001111111111100"};

char MOVE[16][33]=  {"0000000000000001111111",
                    "0000000000000001000001",
                    "0000000000000001000001",
                    "0000000000000001000001",
                    "0000000000000001000001",
                    "0000000000000001000001",
                    "0000000011111001111111",
                    "0000000000011000000000",
                    "0000000001001000000000",
                    "0000000010001000000000",
                    "1111111000000000000000",
                    "1000001000000000000000",
                    "1000001000000000000000",
                    "1000001000000000000000",
                    "1000001000000000000000",
                    "1111111000000000000000"};

char CLIP[16][33]=  {"1010101010101010101010",
                    "0000000000000000000000",
                    "1000000000000000000010",
                    "0000000000000000000000",
                    "1000000000000000000010",
                    "0000000000000000000000",
                    "1000000000000000000010",
                    "0000000000000000000000",
                    "1000000000000000000010",
                    "0000000000000000000000",
                    "1000000000000000000010",
                    "0000000000000000000000",
                    "1000000000000000000010",
                    "0000000000000000000000",
                    "1010101010101010101010",
                    "0000000000000000000000"};

char shapename[13][10]={"LINE    ","BOX    ","FILLBOX ","CIRCLE  ","ELLIPSE",
                        "ERASER  ","FILLER  ","MOVE  ","CLIPBOX ",
                        "        ","        ","        ","      "};
char colorname[16][13]={"BLACK      ","BLUE        ","GREEN      ",
                        "CYAN        ","RED        ","MAGENTA    ",
                        "BROWN      ","LIGHTGRAY  ","DARKGRAY    ",
                        "LIGHTBLUE  ","LIGHTGREEN  ","LIGHTCYAN  ",
                        "LIGHTRED    ","LIGHTMAGENTA","YELLOW      ",
                        "WHITE      "};


int clipx1=1,clipy1=17,clipx2=600,clipy2=400;
int test=0,cliptest=1;
int vfcolor=0,shape=0,area=0;
int xbar=30,ybar=30;
int mx,my,mb=0;

//================================== PUSH ====================================
void push(int x,int y)
{
 STACK *ptr;
 if((ptr=(STACK *)malloc(sizeof(STACK)))==NULL)
  return;
 ptr->x=x;
 ptr->y=y;
 ptr->r=NULL;
 ptr->l=front;
 front=ptr;
 front->r=ptr;
 test++;
}
//==================================== POP ===================================
int pop(int *x,int *y)
{
 STACK *temp;
 char ch;
 test--;
 if(test==-1)
    return(1);

 temp=front->l;
 temp->r=NULL;
 free(front);
 *x=front->x;
 *y=front->y;
 front=temp;
 return(0);
}
//==================================== MOUSE RESET ===========================
int mousereset(void)
{
 _AX=0;
 geninterrupt(0x33);
 return(_AX);
}
//==================================== MOUSE SHOW ============================
void mouseshow(void)
{
 _AX=1;
 geninterrupt(0x33);
}
//==================================== MOUSE HIDE ============================
void mousehide(void)
{
 _AX=2;
 geninterrupt(0x33);
}
//==================================== MOUSE POSITION ========================
void mousepos(void)
{
 _AX=3;
 geninterrupt(0x33);
 mx=_CX;my=_DX;mb=_BX;
 gotoxy(3,1);
 if(mx>1 && my>17 && mx<597 && my<381)
  printf("Pos: %d , %d    ",mx-2,my-18);
}
//==================================== MOUSE UP ==============================
void mouseup(int b)
{
 do
 {
  mousepos();
  //if(mb!=b) return;
 }while(mb & b);
}
//==================================== MOUSE DOWN ============================
void mousedown(int b)
{
 do
 {
  mousepos();
 }while(!(mb & b));
}

//============================================================================
void domode(int m)
{
 union REGS r;
 r.x.ax=m;
 int86(0x10,&r,&r);
}

int getpixel(int px,int py)
{
  union REGS r;
  r.h.ah=0x0d;
  r.h.bh=0;
  r.x.cx=px;
  r.x.dx=py;
  int86(0x10,&r,&r);
  return(r.h.al);
}

void pset(int px,int py,int pcolor)
{
  union REGS r;

  if(px<clipx1 && area && cliptest) px=clipx1+1;
  if(py<clipy1 && area && cliptest) py=clipy1+1;
  if(px>clipx2 && area && cliptest) px=clipx2-1;
  if(py>clipy2 && area && cliptest) py=clipy2-1;

  r.h.ah=0x0c;
  r.h.al=pcolor;
  r.h.bh=0;
  r.x.cx=px;
  r.x.dx=py;
  if(area)
  {
    if(px>clipx1 && px<clipx2 && py>clipy1 && py<clipy2)
      int86(0x10,&r,&r);
  }
  else
  int86(0x10,&r,&r);
}

void line(int x1,int y1,int x2,int y2,int color)
{
  int x,y,dx,dy,ex,temp1,temp2;
  float s1=1,s2=1,e;
  if(x2==x1)
  {
    if(y2<y1) {temp1=y1;y1=y2;y2=temp1;}
    for(int i=y1;i<=y2;i++)
      pset(x1,i,color);
    return;
  }
  else if(y2==y1)
  {
    if(x2<x1) {temp1=x1;x1=x2;x2=temp1;}
    for(int i=x1;i<=x2;i++)
      pset(i,y1,color);
    return;
  }
  x = x1; y = y1;
  dx = abs(x2 - x1);      //length of line
  dy = abs(y2 - y1);      //height of line
  if((x2 - x1 == 0) || (y2 - y1 == 0))
    goto l10;    //vertical or horizontal
  s1 = dx / (x2 - x1);
  s2 = dy / (y2 - y1);
l10:
  if (dy > dx)
    {temp1=dx;
    dx=dy;dy=temp1;
    ex = 1;}
  else
    ex = 0;
  e = 2 * dy - dx;
  for(int k = 0;k<=dx;k++)
  {
    pset(x, y,color);
    //delay(10);
    while(e >= 0)
    {
      if(ex == 1)
        x = x + s1;
      else
      y = y + s2;
      e = e - 2 * dx;
    }
    if(ex == 1)
      y = y + s2;
    else
    x = x + s1;
    e = e + 2 * dy;
  }
}
//============================================================================
void circle(int x,int y,int r,int c)
{
 for(float d=-3.14;d<3.14;d+=3.14/r/10)
  pset(x+r*sin(d),y+r*cos(d),c);
}

//=======================================BOX==================================
void ellipse(int x,int y,int r1,int r2,int c)
{
 for(float d=-3.14;d<3.14;d+=3.14/r1/10)
  pset(x+r1*sin(d),y+r2*cos(d),c);
}
//=======================================BOX==================================
void box(int x1,int y1,int x2,int y2,int c)
{
 line(x1,y1,x2,y1,c);
 line(x2,y1,x2,y2,c);
 line(x1,y2,x2,y2,c);
 line(x1,y1,x1,y2,c);
}
//====================================FILL BOX================================
void fillbox(int x1,int y1,int x2,int y2,int c)
{
 for(int i=y1;i<=y2;i++)
  line(x1,i,x2,i,c);
}
//==================================== FILL ==================================
void fill(int x,int y,int c1)
{
 int c2,n,*x1,*y1,x2,y2;
 int *xt,*yt;
 c2=getpixel(x,y);
// if(x<clipx1 || x>clipx2 || y<clipy1 || y>clipy2)
 //  return;
 xt=&x;yt=&y;
 push(*xt,*yt);
 do
 {
  mousepos();
  if(mb==2)
    {do{}while(pop(xt,yt)!=1);return;}
  pset(*xt,*yt,c1);
  if(getpixel(*xt,*yt-1)!=c1 && getpixel(*xt,*yt-1)==c2) push(*xt,*yt-1);
  if(getpixel(*xt,*yt+1)!=c1 && getpixel(*xt,*yt+1)==c2) push(*xt,*yt+1);
  if(getpixel(*xt-1,*yt)!=c1 && getpixel(*xt-1,*yt)==c2) push(*xt-1,*yt);
  if(getpixel(*xt+1,*yt)!=c1 && getpixel(*xt+1,*yt)==c2) push(*xt+1,*yt);
 }while(pop(xt,yt)!=1);
}
//============================================================================
void setcolores(void)
{
 for(int i=0;i<16;i++)
  fillbox(i*37+25,420,i*37+58,460,i);
 box(vfcolor*37+25-2,420-5,vfcolor*37+58+2,460+5,15);

// line(vbcolor*37+25-3,420-7,vbcolor*37+58+3,420-7,14);
// line(vbcolor*37+25-3,460+7,vbcolor*37+58+3,460+7,14);
 gotoxy(35,1);printf("Color: %s",colorname[vfcolor]);

}
//============================================================================
void setshape(void)
{
 for(int i=0;i<13;i++)
  box(607,i*30+5,637,(i+1)*30+5,8);
 line(613,10,630,30,14);
 box(612,40,631,60,14);
 fillbox(612,70,631,90,14);
 circle(622,111,10,14);
 ellipse(622,141,12,7,14);
 //---------------------Eraser
 for(i=0;i<16;i++)
  for(int j=0;j<32;j++)
    if(Eraser[i][j]=='1')
      pset(j+612,i+165,14);
 box(615,159,620,167,14);
 circle(627,160,4,14);

 //---------------------Filler
  for(i=0;i<16;i++)
  for(j=0;j<32;j++)
    if(Filler[i][j]=='1')
      pset(j+610,i+192,14);

  //---------------------MOVE
  for(i=0;i<16;i++)
  for(j=0;j<32;j++)
    if(MOVE[i][j]=='1')
      pset(j+612,i+220,8);
  //---------------------CLIP
  for(i=0;i<16;i++)
  for(j=0;j<32;j++)
    if(CLIP[i][j]=='1')
      pset(j+612,i+252,14);

  circle(623,290,8,8);
  circle(623,290,4,8);
  fill(623,290,15);
 box(607,shape*30+5,637,(shape+1)*30+5,12);
 gotoxy(60,1);printf("Shape: %s",shapename[shape]);
}
//============================================================================
void selectshape(int mbutton)
{
 int stemp=shape;
 area=0;
 if(mbutton==1)
  for(int i=0;i<13;i++)
    if(mx>=607 && my>=i*30+5 && mx<=637 && my<=(i+1)*30+5)
      {
      stemp=shape;
      shape=i;
      if(stemp!=shape)
        {
          mousehide();
          box(607,stemp*30+5,637,(stemp+1)*30+5,8);
          box(607,shape*30+5,637,(shape+1)*30+5,12);
          gotoxy(60,1);printf("Shape: %s",shapename[shape]);
          mouseshow();
        }
        break;
      }
  if(shape==10)
    if(cliptest==1)
      {fill(623,290,0);cliptest=0;}
    else
      {fill(623,290,15);cliptest=1;}
  area=1;
}
//============================================================================
void selectcolor(int mbutton)
{
 char chkey;
 int vctemp;

 area=0;
 for(int i=0;i<16;i++)
  if(mx>=i*37+25 && my>=420 && mx<=i*37+58 && my<=460)
    {
      if(mbutton==1)
      {
        vctemp=vfcolor;
        vfcolor=i;
        if(vctemp!=vfcolor)
        {
          mousehide();
          box(vctemp*37+25-2,420-5,vctemp*37+58+2,460+5,0);
          box(vfcolor*37+25-2,420-5,vfcolor*37+58+2,460+5,15);
          gotoxy(35,1);printf("Color: %s",colorname[vfcolor]);
          mouseshow();
          break;
        }
      }
    }//First IF
  area=1;
}
//=====================================DODRAW=================================
void dodraw(void)
{
 int x1,y1,x2,y2;
 area=1;
 if(shape==0)                //line
  {
    x1=mx;y1=my;
    mouseup(1);
    mousepos();
    x2=mx;y2=my;
    mousehide();
    line(x1,y1,x2,y2,vfcolor);
    mouseshow();
  }
 else if(shape==1)        //box
  {
    x1=mx;y1=my;
    mouseup(1);
    mousepos();
    x2=mx;y2=my;
    mousehide();
    box(x1,y1,x2,y2,vfcolor);
    mouseshow();
  }
  else if(shape==2)        //eraser
  {
    x1=mx;y1=my;
    mouseup(1);
    mousepos();
    x2=mx;y2=my;
    mousehide();
    fillbox(x1,y1,x2,y2,vfcolor);
    mouseshow();
  }

  else if(shape==3)        //circle
  {
    x1=mx;y1=my;
    mouseup(1);
    mousepos();
    x2=mx;y2=my;
    if(x1!=x2 && y1!=y2)
    {
      mousehide();
      int radius=sqrt(pow(x1-x2,2.0)+pow(y1-y2,2.0));
      circle(x1,y1,radius,vfcolor);
      mouseshow();
    }
  }
  else if(shape==4)        //ellipse
  {
    x1=mx;y1=my;
    mouseup(1);
    mousepos();
    x2=mx;y2=my;
    if(x1!=x2 && y1!=y2)
    {
      mousehide();
      int r1=abs(x1-x2);
      int r2=abs(y1-y2);
      ellipse(x1,y1,r1,r2,vfcolor);
      mouseshow();
    }
  }
    else if(shape==5)        //fillbox
  {
    x1=mx;y1=my;
    mousepos();
    mousehide();
    fillbox(x1-10,y1-10,x1+10,y1+10,0);
    mouseshow();
  }
  else if(shape==6)        //fill
  {
    x1=mx;y1=my;
    mousehide();
    fill(x1,y1,vfcolor);
    mouseshow();
  }
  else if(shape==8)        //CLIP
  {
    area=0;
    box(clipx1-1,clipy1-1,clipx2+1,clipy2+1,0);
    clipx1=1;clipy1=17;clipx2=600;clipy2=400;
    area=1;
    x1=mx;y1=my;
    mouseup(1);
    mousepos();
    x2=mx;y2=my;
    if(x1<1) x1=1;
    if(y1<17) y1=17;
    if(x2>599) x2=599;
    if(y2>399) y2=399;
    mousehide();
    box(x1,y1,x2,y2,8);
    clipx1=x1+1;clipx2=x2-1;clipy1=y1+1;clipy2=y2-1;
    area=1;
    mouseshow();
  }
}
//===================================INITSCREEN===============================
void initscreen(void)
{
 box(0,16,600,400,11);
 box(1,17,601,401,11);
 box(605,0,639,400,3);
 box(3,405,639,479,3);
 setcolores();
 area=0;
 setshape();
}

//===================================KeyProcess===============================
void keyprocess(void)
{
 int cp;

 while(1)
 {
  mousepos();
  if(kbhit())
    if(getch()==27)
    {domode(3);
      return;
    }
  if(mx>=608 && mx<=635 && my>=276 && my<=305 && mb==1)
  {
    area=0;
    mousehide();
    if(cliptest==1)
      {fill(623,290,0);cliptest=0;}
    else
      {fill(623,290,15);cliptest=1;}
    mouseshow();
    mouseup(1);
    area=1;
  }

  if(mx>=25 && mx<= 613 && my>=420 && my<=460)
    selectcolor(mb);
  else if(mx>=607 && mx<= 635 && my>=5 && my<=255+18)
    selectshape(mb);
  else if(mx>=2 && mx<= 598 && my>=2 && my<=398)
    if(mb==1) dodraw();
 }
}
//============================================================================
//===================================  MAIN  ===============================
//============================================================================
void main()
{
 if(!mousereset())
  {
  printf("\nMouse Driver not installed!");
  return;
  }
 clrscr();
 domode(0x12);        //graphic 640x480
 initscreen();
 mouseshow();
 keyprocess();
}

---

اون تابع MousePos هم براي نشون دادن موقعيت ماوس هست كه تعريف شده
براي راه‌حلي هم كه آرام ميخواد پياده كني ميتوني خيلي راحت از يه آرايه از نوع استراكچر دو عضوي استفاده كني كه به ازاي هر كليك يه انديس جلو بري و موقيت ماوس رو ذخيره كني تا اينكه به نقطه شروع برسي يا كاربر كليك راست كنه و نقطه آخر رو به اول وصل كني. در ضمن اين كد شامل رسم خط و مستطيل و دايره و ... هم هست كه ميتونه كمكت كنه. تابع پر كردن هم ممكنه اشكالاتي توي سطوح خيلي بزرگ داشته باشه كه فرصت نكردم اصلاحش كنم. بهر حال اميدوارم كمكت كنه

دوباره سلام.
برای رسم یه polygon میتونید از برنامه زیر استفاده کنین:

کد:

---


 
# include "stdlib.h"
#include "iostream"
#include "graphics.h"
using namaspace std;
#define TRUE 1
struct PolyPoints
{
 int x;
 int y;
};
void CreatePoly(PolyPoints* points);
void main()
{
 int gd = DETECT , gm ;
 initgraph(&gd , &gm , "C:\\Red\Language\\TC\\BGI");
 int ec = graphresult();
 if (ec !=0)
 {
  cout<<"Graph Error "<<grapherrormsg(ec);
  getch();
  exit(0);
 }
 PolyPoints points[4];
 points[0].x = 10;
 points[0].y = 10;
 points[1].x = 10;
 points[1].y = 60;
 points[2].x = 100;
 points[2].y = 100;
 points[3].x = 100;
 points[3].y = 250;
 CreatePoly(points);
}
void CreatePoly(PolyPoints* points)
{
 int i=0;
 while ( TRUE  )
 {
  moveto(points[i].x,points[i].y);
  i++;
  if (points[i].x == NULL  || points[i].y == NULL)
  break;
  lineto(points[i].x,points[i].y);
 }
  lineto(points[0].x,points[0].y);
}

---

یک struc داریم که مختصات x,y رو در خودش ذخیره میکنه.برای رسم polygon هم کافیه در ابتدا به اولین
نقطه حرکت کنیم و به نقطه ی بعدی خط رسم کنیم. در پایان هم از آخرین مختصات به مختصات آغازین خطی
رسم میکنیم. نمونه ساده ای هست.
اما در مورد پرکردنش و روشی که شما پیشنهاد دادین:
با استفاده از یه حلقه pixel به pixel محور افقی رو جاروب میکنیم و با استفاده از getpixel مقدار رنگ نقطه ی
مورد نظر رو بدست میاریم. هر وقت به اولین نقطه ی سفید رسیدیم با استفاده از putpixel یک نقطه ی
سفید رسم میکنیم و دوباره رنگ نقطه ی بعدی رو مقایسه میکنیم اگه سیاه بود دوباره از putpixel استفاده
میکنیم. و اگه سفید بود یعنی به انتها رسیدیم. بعد از اتمام مقدار محور عمودی رو یکی زیاد میکنیم و دوباره
عملیات رو انجام میدیم. تا کل صفحه رو scan کنیم. سعی کنین برنامه رو بنویسن. اگه به مشکل بر خوردین
اطلاع بدین.
اما روش زیاد سنجیده ای نیست. فرض کنین که screen شما 480*640 باشه. یعنی 307200 جستجو .
البته این مقدار max هست. بستگی داره که شکل در کجا باشه. هر چی از مرکز مختصات دورتر باشه جستجو
به عدد مورد نظر نزدیک تر میشه. وزمان زیادی میبره.

سلام
دوست دارم كه راه شما (كاربرsomeone ) راهم براي پر كردن يك polygon بدونم

مرسي

دوباره سلام.
همون که دوستمون گفتن به طور کلی دو روش برای Fill کردن اشکال وجود داره.
1- Boundary Fill Algorithm
2- Scan line polygon fillling Algorithm
در مورد روش اول که دوستون توضیحش رو دادن. و یه نمونه از اون گذاشتن. (8 تایی)
اگه نظر من رو بخواید روش خیلی خوبی هست و خیلی ساده میشه پیادش کرد.
نمونه ای دوستمون گذاشتن رو با کمی تغییر براتون میذارم :

کد:

---


 
void  BoundryFill(int x, int y,int fill,int bound)
{
 int cur;
 cur=getpixel(x,y);
 if(cur!=bound && cur!= fill)
 {
  putpixel(x,y,fill);
  BoundryFill(x+1, y,fill,bound);
  BoundryFill(x-1, y,fill,bound);
  BoundryFill(x, y-1,fill,bound);
  BoundryFill(x, y+1,fill,bound);
 }
}

---

می بینید که کد خیلی ساده ای هست. به این صورت میتونین ازش استفاده کنین:
x,y مختصات نقطه ای از درون polygon هست. fill مقدار رنگ مورد نظرتون و bound مقدار رنگ مرز های
polygon هست. اگه مشکلی پیش اومد اطلاع بدین.