mam cztery wierzcholki prostokata

int Ax, Ay, Bx, By, Cx, Cy, Dx, Dy;

ktore maja przypisane wartosci, potrzebuje te
wartosci przwpisac do

int upX, upY, downX, downY, leftX, leftY, rightX, rightY;

zgodnie z nazwami tj ten najbardziej z lewej do leftX leftY
itp, jak to zrobic w prosty sposob?


--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

> Wysłano z serwisu Usenet w portalu Gazeta.pl ->

a dlaczego nikt Cię jeszcze od troli nie nawyzyał?

do góry

<f...@g...SKASUJ-TO.pl> napisał(a):

> mam cztery wierzcholki prostokata
>
> int Ax, Ay, Bx, By, Cx, Cy, Dx, Dy;
>
> ktore maja przypisane wartosci, potrzebuje te
> wartosci przwpisac do
>
> int upX, upY, downX, downY, leftX, leftY, rightX, rightY;
>
> zgodnie z nazwami tj ten najbardziej z lewej do leftX leftY
> itp, jak to zrobic w prosty sposob?

Funkcje min i max będą przydatne.
Pozdrawiam



--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

M.M. <m...@W...gazeta.pl> napisał(a):

> <f...@g...SKASUJ-TO.pl> napisał(a):
>
> > mam cztery wierzcholki prostokata
> >
> > int Ax, Ay, Bx, By, Cx, Cy, Dx, Dy;
> >
> > ktore maja przypisane wartosci, potrzebuje te
> > wartosci przwpisac do
> >
> > int upX, upY, downX, downY, leftX, leftY, rightX, rightY;
> >
> > zgodnie z nazwami tj ten najbardziej z lewej do leftX leftY
> > itp, jak to zrobic w prosty sposob?
>
> Funkcje min i max będą przydatne.

to by bylo chyba za dlugie, chyba moge to zrobic sprawdzajac
w jakiej cwiartce jest wektor B-A (mozna zalozyc ze ABCD sa
uporzadkowane np prawoskretnie wiec chyba powinno byc ok)



--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

Dnia Fri, 6 Apr 2012 21:23:23 +0200, identifikator: 20040501 napisał(a):

>> Wysłano z serwisu Usenet w portalu Gazeta.pl ->
>
> a dlaczego nikt Cię jeszcze od troli nie nawyzyał?

Dlatego, że fir jest porządnym rozmówcą w porównaniu z Tobą.

do góry

Użytkownik <f...@W...gazeta.pl> napisał w wiadomości grup
dyskusyjnych:jlol4d$h1d$...@i...gazeta.pl...
> M.M. <m...@W...gazeta.pl> napisał(a):
>
>> <f...@g...SKASUJ-TO.pl> napisał(a):
>>
>> > mam cztery wierzcholki prostokata
>> >
>> > int Ax, Ay, Bx, By, Cx, Cy, Dx, Dy;
>> >
>> > ktore maja przypisane wartosci, potrzebuje te
>> > wartosci przwpisac do
>> >
>> > int upX, upY, downX, downY, leftX, leftY, rightX, rightY;
>> >
>> > zgodnie z nazwami tj ten najbardziej z lewej do leftX leftY
>> > itp, jak to zrobic w prosty sposob?
>>
>> Funkcje min i max będą przydatne.
>
> to by bylo chyba za dlugie, chyba moge to zrobic sprawdzajac
> w jakiej cwiartce jest wektor B-A (mozna zalozyc ze ABCD sa
> uporzadkowane np prawoskretnie wiec chyba powinno byc ok)

Posortować oddzielnie (Ax, Bx, Cx, Dx) i (Ay, By, Cy, Dy).

Lewe są te z najmniejszymi x-sami, górne te z najmniejszymi (największymi?
zależy od przyjętego układu współrzędnych) y-kami.

Trochę logiki i powinno działać.

Funkcje min i max nie będą (chyba) szybsze niż if-else .

Najogólniej? Są 24 przypadki, wystarczy "zajarzyć" który z nich i już jest
prosto.

do góry

slawek <s...@h...pl> napisał(a):

>
> Użytkownik <f...@W...gazeta.pl> napisał w wiadomości grup
> dyskusyjnych:jlol4d$h1d$...@i...gazeta.pl...
> > M.M. <m...@W...gazeta.pl> napisał(a):
> >
> >> <f...@g...SKASUJ-TO.pl> napisał(a):
> >>
> >> > mam cztery wierzcholki prostokata
> >> >
> >> > int Ax, Ay, Bx, By, Cx, Cy, Dx, Dy;
> >> >
> >> > ktore maja przypisane wartosci, potrzebuje te
> >> > wartosci przwpisac do
> >> >
> >> > int upX, upY, downX, downY, leftX, leftY, rightX, rightY;
> >> >
> >> > zgodnie z nazwami tj ten najbardziej z lewej do leftX leftY
> >> > itp, jak to zrobic w prosty sposob?
> >>
> >> Funkcje min i max będą przydatne.
> >
> > to by bylo chyba za dlugie, chyba moge to zrobic sprawdzajac
> > w jakiej cwiartce jest wektor B-A (mozna zalozyc ze ABCD sa
> > uporzadkowane np prawoskretnie wiec chyba powinno byc ok)
>
> Posortować oddzielnie (Ax, Bx, Cx, Dx) i (Ay, By, Cy, Dy).
>
> Lewe są te z najmniejszymi x-sami, górne te z najmniejszymi (największymi?
> zależy od przyjętego układu współrzędnych) y-kami.
>
> Trochę logiki i powinno działać.
>
> Funkcje min i max nie będą (chyba) szybsze niż if-else .
>
> Najogólniej? Są 24 przypadki, wystarczy "zajarzyć" który z nich i już jest
> prosto.

Jeśli to ma być szybko, to bez ifów i z wykorzystaniem specyficznych cech
danych wejściowych. Jeśli zmienne są nazywane leftX i leftY to rozumiem,
że chodzi tylko o takie kwadraty które da się opisać czterema liczbami:
dwie współrzędne lewego górnego rogu i dwie prawego dolnego. Do wyświetlania
na monitorze w zupełności wystarczy 16 bitów, daje to sporą rozdzielczość
65tys na 65tys punktów logicznych czy tam fizycznych. Czyli apropo
struktury danych mamy cztery liczby upakowane do jednej 64 bitowej, najlepiej
jakby ona znalazła się w rejestrze.

Mamy cztery dane wejściowe:
Ax, Ay, Bx, By, Cx, Cy, Dx, Dy
Być może to już jest błędem, może algorytm wypluwający te dane da się
tak przebudować, aby dawał tylko 4 liczby, gdyż każda współrzędna dla
prostokąta obróconego o wielokrotność 90 stopni występuje dwa razy. Jeśli
się da algorytm wypluwający przebudować, to wystarczy porównać dwie
liczby if( a < b ) szesnastobitowe utworzone odpowiednio z bitów 0-15 i
32-47. W przypadku gdy współrzędne są podawane tak jak zwykle, czyli
najpierw x a potem y, to w przypadku gdy a < b wiemy że lewy górny punkt
jest zakodowany w bitach 0-31, prawy dolny w bitach 32-64 i nic nie musimy
zmieniać. W przypadku gdy a > b to musimy zamienić 32 bity młodsze ze starszymi.

Mniej/więcej coś takiego:
uint64 swp_corners( uint64 input ) {
const uint32 tmp = ( ( input & x_corner_1 ) >> offset_x1 ) < ( ( input &
x_corner_2 ) >> offset_x2 );
return (input>>(32*tmp))|(input<<(32*tmp));
}

Można pomyśleć jeszcze jak w tmp uzyskać jedynkę gdy wynik porównywania
jest prawdziwy i zero gdy jest nieprawdziwy w sposób niewymagający użycia
operatora mniejszości. Tak żeby kompilator nie wstawiał instrukcji
jum_if_less.

Pozdrawiam




--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

M.M. <m...@W...gazeta.pl> napisał(a):

> slawek <s...@h...pl> napisał(a):
>
> >
> > Użytkownik <f...@W...gazeta.pl> napisał w wiadomości grup
> > dyskusyjnych:jlol4d$h1d$...@i...gazeta.pl...
> > > M.M. <m...@W...gazeta.pl> napisał(a):
> > >
> > >> <f...@g...SKASUJ-TO.pl> napisał(a):
> > >>
> > >> > mam cztery wierzcholki prostokata
> > >> >
> > >> > int Ax, Ay, Bx, By, Cx, Cy, Dx, Dy;
> > >> >
> > >> > ktore maja przypisane wartosci, potrzebuje te
> > >> > wartosci przwpisac do
> > >> >
> > >> > int upX, upY, downX, downY, leftX, leftY, rightX, rightY;
> > >> >
> > >> > zgodnie z nazwami tj ten najbardziej z lewej do leftX leftY
> > >> > itp, jak to zrobic w prosty sposob?
> > >>
> > >> Funkcje min i max będą przydatne.
> > >
> > > to by bylo chyba za dlugie, chyba moge to zrobic sprawdzajac
> > > w jakiej cwiartce jest wektor B-A (mozna zalozyc ze ABCD sa
> > > uporzadkowane np prawoskretnie wiec chyba powinno byc ok)
> >
> > Posortować oddzielnie (Ax, Bx, Cx, Dx) i (Ay, By, Cy, Dy).
> >
> > Lewe są te z najmniejszymi x-sami, górne te z najmniejszymi
(największymi?
> > zależy od przyjętego układu współrzędnych) y-kami.
> >
> > Trochę logiki i powinno działać.
> >
> > Funkcje min i max nie będą (chyba) szybsze niż if-else .
> >
> > Najogólniej? Są 24 przypadki, wystarczy "zajarzyć" który z nich i już
jest
> > prosto.
>
> Jeśli to ma być szybko, to bez ifów i z wykorzystaniem specyficznych cech
> danych wejściowych. Jeśli zmienne są nazywane leftX i leftY to rozumiem,
> że chodzi tylko o takie kwadraty które da się opisać czterema liczbami:
> dwie współrzędne lewego górnego rogu i dwie prawego dolnego. Do wyświetlania
> na monitorze w zupełności wystarczy 16 bitów, daje to sporą rozdzielczość
> 65tys na 65tys punktów logicznych czy tam fizycznych. Czyli apropo
> struktury danych mamy cztery liczby upakowane do jednej 64 bitowej,
najlepiej
> jakby ona znalazła się w rejestrze.
>
> Mamy cztery dane wejściowe:
> Ax, Ay, Bx, By, Cx, Cy, Dx, Dy
> Być może to już jest błędem, może algorytm wypluwający te dane da się
> tak przebudować, aby dawał tylko 4 liczby, gdyż każda współrzędna dla
> prostokąta obróconego o wielokrotność 90 stopni występuje dwa razy. Jeśli
> się da algorytm wypluwający przebudować, to wystarczy porównać dwie
> liczby if( a < b ) szesnastobitowe utworzone odpowiednio z bitów 0-15 i
> 32-47. W przypadku gdy współrzędne są podawane tak jak zwykle, czyli
> najpierw x a potem y, to w przypadku gdy a < b wiemy że lewy górny punkt
> jest zakodowany w bitach 0-31, prawy dolny w bitach 32-64 i nic nie musimy
> zmieniać. W przypadku gdy a > b to musimy zamienić 32 bity młodsze ze
starszymi
> .
>
> Mniej/więcej coś takiego:
> uint64 swp_corners( uint64 input ) {
> const uint32 tmp = ( ( input & x_corner_1 ) >> offset_x1 ) < ( ( input &
> x_corner_2 ) >> offset_x2 );
> return (input>>(32*tmp))|(input<<(32*tmp));
> }
>
> Można pomyśleć jeszcze jak w tmp uzyskać jedynkę gdy wynik porównywania
> jest prawdziwy i zero gdy jest nieprawdziwy w sposób niewymagający użycia
> operatora mniejszości. Tak żeby kompilator nie wstawiał instrukcji
> jum_if_less.
>

nienie chodzi mi o cos innego


a b c d to wierzcholki przekrzywionego (obroconego o kat alfa)
prostokata, mozna tez zalozyc ze sa uporzadkowane np prawoskretnie

zrobilem cos takiego

WX_ = qBx-qAx;
WY_ = qBy-qAy;

if(WX_>0)
{
if(WY_>0)
{
upx = qBx; upy = qBy;
rightx = qCx;righty = qCy;
downx = qDx; downy = qDy;
leftx = qAx; lefty = qAy;
}
else
{
upx = qAx; upy = qAy;
rightx = qBx;righty = qBy;
downx = qCx; downy = qCy;
leftx = qDx; lefty = qDy;
}

}
else if(WX_<0)
{
if(WY_>0)
{
// dabc
upx = qCx; upy = qCy;
rightx = qDx;righty = qDy;
downx = qAx; downy = qAy;
leftx = qBx; lefty = qBy;



}
else
{
upx = qDx; upy = qDy;
rightx = qAx;righty = qAy;
downx = qBx; downy = qBy;
leftx = qCx; lefty = qCy;


}

}
else
{
}

to uporzadkowanie jest mi potrzebne by pozniej
wyrysowac quada na ekranie przez cos w stylu

dxleft = ((upx-leftx)<<10)/(lefty-upy);
dxright = ((upx-rightx)<<10)/(righty-upy);
xs = upx<<10;
xk = upx<<10;



int y = upy;

int dxs = dxleft;
int dxk = dxright;


for(;;)
{

drawPozioma(y, xs>>10, xk>>10, color);

if(y==downy) break;

y--;
xs+=dxs;
xk+=dxk;

if(y==lefty) dxs = dxright;
if(y==righty) dxk = dxleft;


}


ale trzeba uwzglednic tez przypadki gdy punkty w gornej lini sa dwa
(i to wcale nie jest wtedy koniecznie prosty prostakat)
- bez przerwy leca jakies bledy i nie mog edefekto doprowadzic
tego prostego cholerstwa do dzialania jest dziwnie frustrujace
(podobnie nie moge znalezc dobrego przykladu na renderowanie
przekrzywionych prostokatow w necie)




--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

<f...@W...gazeta.pl> napisał(a):

> M.M. <m...@W...gazeta.pl> napisał(a):
>
> > slawek <s...@h...pl> napisał(a):
> >
> > >
> > > Użytkownik <f...@W...gazeta.pl> napisał w wiadomości grup
> > > dyskusyjnych:jlol4d$h1d$...@i...gazeta.pl...
> > > > M.M. <m...@W...gazeta.pl> napisał(a):
> > > >
> > > >> <f...@g...SKASUJ-TO.pl> napisał(a):
> > > >>
> > > >> > mam cztery wierzcholki prostokata
> > > >> >
> > > >> > int Ax, Ay, Bx, By, Cx, Cy, Dx, Dy;
> > > >> >
> > > >> > ktore maja przypisane wartosci, potrzebuje te
> > > >> > wartosci przwpisac do
> > > >> >
> > > >> > int upX, upY, downX, downY, leftX, leftY, rightX, rightY;
> > > >> >
> > > >> > zgodnie z nazwami tj ten najbardziej z lewej do leftX leftY
> > > >> > itp, jak to zrobic w prosty sposob?
> > > >>
> > > >> Funkcje min i max będą przydatne.
> > > >
> > > > to by bylo chyba za dlugie, chyba moge to zrobic sprawdzajac
> > > > w jakiej cwiartce jest wektor B-A (mozna zalozyc ze ABCD sa
> > > > uporzadkowane np prawoskretnie wiec chyba powinno byc ok)
> > >
> > > Posortować oddzielnie (Ax, Bx, Cx, Dx) i (Ay, By, Cy, Dy).
> > >
> > > Lewe są te z najmniejszymi x-sami, górne te z najmniejszymi
> (największymi?
> > > zależy od przyjętego układu współrzędnych) y-kami.
> > >
> > > Trochę logiki i powinno działać.
> > >
> > > Funkcje min i max nie będą (chyba) szybsze niż if-else .
> > >
> > > Najogólniej? Są 24 przypadki, wystarczy "zajarzyć" który z nich i już
> jest
> > > prosto.
> >
> > Jeśli to ma być szybko, to bez ifów i z wykorzystaniem specyficznych cech
> > danych wejściowych. Jeśli zmienne są nazywane leftX i leftY to rozumiem,
> > że chodzi tylko o takie kwadraty które da się opisać czterema liczbami:
> > dwie współrzędne lewego górnego rogu i dwie prawego dolnego. Do wyświetlania
> > na monitorze w zupełności wystarczy 16 bitów, daje to sporą rozdzielczość
> > 65tys na 65tys punktów logicznych czy tam fizycznych. Czyli apropo
> > struktury danych mamy cztery liczby upakowane do jednej 64 bitowej,
> najlepiej
> > jakby ona znalazła się w rejestrze.
> >
> > Mamy cztery dane wejściowe:
> > Ax, Ay, Bx, By, Cx, Cy, Dx, Dy
> > Być może to już jest błędem, może algorytm wypluwający te dane da się
> > tak przebudować, aby dawał tylko 4 liczby, gdyż każda współrzędna dla
> > prostokąta obróconego o wielokrotność 90 stopni występuje dwa razy. Jeśli
> > się da algorytm wypluwający przebudować, to wystarczy porównać dwie
> > liczby if( a < b ) szesnastobitowe utworzone odpowiednio z bitów 0-15 i
> > 32-47. W przypadku gdy współrzędne są podawane tak jak zwykle, czyli
> > najpierw x a potem y, to w przypadku gdy a < b wiemy że lewy górny punkt
> > jest zakodowany w bitach 0-31, prawy dolny w bitach 32-64 i nic nie musimy
> > zmieniać. W przypadku gdy a > b to musimy zamienić 32 bity młodsze ze
> starszymi
> > .
> >
> > Mniej/więcej coś takiego:
> > uint64 swp_corners( uint64 input ) {
> > const uint32 tmp = ( ( input & x_corner_1 ) >> offset_x1 ) < ( ( input &
> > x_corner_2 ) >> offset_x2 );
> > return (input>>(32*tmp))|(input<<(32*tmp));
> > }
> >
> > Można pomyśleć jeszcze jak w tmp uzyskać jedynkę gdy wynik porównywania
> > jest prawdziwy i zero gdy jest nieprawdziwy w sposób niewymagający użycia
> > operatora mniejszości. Tak żeby kompilator nie wstawiał instrukcji
> > jum_if_less.
> >
>
> nienie chodzi mi o cos innego
>
>
> a b c d to wierzcholki przekrzywionego (obroconego o kat alfa)
> prostokata, mozna tez zalozyc ze sa uporzadkowane np prawoskretnie

Jeśli chcesz tak super optymalizować to może zapamiętaj je inaczej?
Wystarczy pięć liczb: szerokość, wysokość, (x,y) środka i kąt obrotu?
9 bitów na kąt obrotu, to zostaje 64-9=55. 55 podzielić przez cztery
pozostałe dane daje ponad 13 bitów, czyli w rozdzielczości 8tys na 8tys
zadziała :)
Pozdrawiam



--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

Użytkownik " M.M." <m...@W...gazeta.pl> napisał w wiadomości grup
dyskusyjnych:jlqhf7$9i8$...@i...gazeta.pl...
> Jeśli to ma być szybko, to bez ifów i z wykorzystaniem specyficznych cech
...
> zmieniać. W przypadku gdy a > b to musimy zamienić 32 bity młodsze ze
> starszymi.
>
> Mniej/więcej coś takiego:
> uint64 swp_corners( uint64 input ) {
> const uint32 tmp = ( ( input & x_corner_1 ) >> offset_x1 ) < ( ( input &
...

Dziecko drogie, a jaka jest różnica pomiędzy jawnie napisanym if(a > b) - a
operacją porównywania a > b ?

Na poziomie kodu maszynowego - żadna. Musi być jakieś cmp, musi być potem
skutek tego cmp. Nie ma się co szamotać, że "uda się bez if" - bo te if
będzie dalej, tyle że zagrzebane w nieczytelnym kodzie.

Kolejna sprawa - pakowanie bitów do czegoś. Ok. Może mieć sens. Ale jeżeli
pakujesz 4 int16 do int64 ... to po prostu robisz niepotrzebną rzecz -
szybciej i łatwiej będzie to np. działało na strukturze czy nawet
oddzielnych zmiennych. Znowu liczy się kod maszynowy - a nie twoje dobre
chęci.

do góry