Kąt między dwoma odcinkami.

Cześć. Chcę wykorzystać OpenCV do jednego z moich projektów. Potrzebuję zdobyć informacje o kącie między dwoma odcinkami. Naskrobałem kod, ale czy wedłóg was jest prawidłowy i sensowny ? Niby wyniki dostaje w przybliżeniu dobre:

double LogicalLine::AngleBetweanEachNeightbour(char sideOfNeightbour, int indexOfNeightbour)
{
	std::vector<LogicalLine*> tempNeightbours;

	if(sideOfNeightbour == 'A')
      tempNeightbours = this->linesNearA;
	else if(sideOfNeightbour == 'B')
	  tempNeightbours = this->linesNearB;

	LogicalLine* l = tempNeightbours[indexOfNeightbour];

	Point vectorOfOwner;
	if(A.x > B.x)
	{
		vectorOfOwner.x = A.x - B.x;
		vectorOfOwner.y = A.y - B.y;
	}else
	{
		vectorOfOwner.x = B.x - A.x;
		vectorOfOwner.y = B.y - A.y;
	}

	Point vectorOfNeightbour;
	if(l->A.x > l->B.x)
	{
		vectorOfNeightbour.x = l->A.x - l->B.x;
		vectorOfNeightbour.y = l->A.y - l->B.y;
	}else
	{
		vectorOfNeightbour.x = l->B.x - l->A.x;
		vectorOfNeightbour.y = l->B.y - l->A.y;
	}

	double degreesOwner = std::atan2(vectorOfOwner.y, vectorOfOwner.x) * 180 / M_PI;
	if (degreesOwner > 90)
	{
	    degreesOwner = 450 - degreesOwner;
	}
	else
	{
	    degreesOwner = 90 - degreesOwner;
	}

	double degreesNeightbour = std::atan2(vectorOfNeightbour.y, vectorOfNeightbour.x)* 180 / M_PI;
	if (degreesNeightbour > 90)
	{
	    degreesNeightbour = 450 - degreesNeightbour;
	}
	else
	{
	    degreesNeightbour = 90 - degreesNeightbour;
	}

	return abs(degreesNeightbour - degreesOwner);
}
 

Jak widzimy, jest to metoda klasy LogicalLine, która winna liczyć kąt między mną (tą linią) a jej wybranym sąsiadem. Przyznam się, że musiałem sobie odświeżyć wiedzę z geometrii, jednak chciałbym zasięgnąć jeszcze czyjejś opini - może można to policzyć prościej ??

Z góry dzięki za zainteresowanie.

lukas_gab napisał(a):

Przyznam się, że musiałem sobie odświeżyć wiedzę z geometrii, jednak chciałbym zasięgnąć jeszcze czyjejś opini - może można to policzyć prościej ??

Kiepsko odświeżyłeś, zamiast:

    double degreesOwner = std::atan2(vectorOfOwner.y, vectorOfOwner.x) * 180 / M_PI;
    if (degreesOwner > 90)
    {
        degreesOwner = 450 - degreesOwner;
    }
    else
    {
        degreesOwner = 90 - degreesOwner;
    }

użyj:

double degreesOwner=std::fmod(std::atan2(vectorOfOwner.x,vectorOfOwner.y)*180/M_PI+360,360);

No chyba że pasuje ci kąt w granicach -180..180 wtedy wystarczy: double degreesOwner=std::atan2(vectorOfOwner.x,vectorOfOwner.y)*180/M_PI;

Czy te odcinki mają wspólny punkt?

Mogą mieć, lecz nie muszą. Jestem wstanie to zbadać, jednak muszę zakładać, że mogą to byc dwa dowolne odcinki na płaszczyźnie, nawet lerzące na tej samej prostej.

I ok, jeżeli użyję twojej propozycji to dostaję w takim razie miarę kontów między dwoma wektorami powstałymi z przesuniętego odcinka a osią X. Wtedy ich różnica będzie mairą kąta między tymi dwoma odcinkami ??

@_13th_Dragon - masz rację - napsiałem bez zastanowienia co ta funkcja właściwie robi. Wyniki twojej propozycji są takie same jak mojej, ale już abstrachując od kwesti technicznej, czy logicznie dobrze rozumują z wyliczeniem tych kątów między tymi dwoma odcinkami ?

Zrób z tego metodę (np prywatną):

Point vectorOfOwner;
    if(A.x > B.x)
    {
        vectorOfOwner.x = A.x - B.x;
        vectorOfOwner.y = A.y - B.y;
    }else
    {
        vectorOfOwner.x = B.x - A.x;
        vectorOfOwner.y = B.y - A.y;
    }

czyli:

Point LogicalLine::dxy() { return A.x>B.x?Point(A.x-B.x,A.y-B.y):Point(B.x-A.x,B.y-A.y); }

Oraz dodaj metodę:

std::vector<LogicalLine*> &LogicalLine::getLinear(char sideOfNeightbour) { return sideOfNeightbour=='A'?linesNearA:linesNearB; }

Wtedy:

double LogicalLine::AngleBetweanEachNeightbour(char sideOfNeightbour, int indexOfNeightbour)
  {
   Point a=dxy();
   Point b=getLinear(sideOfNeightbour)[indexOfNeightbour]->dxy();
   return std::fmod((std::atan2(b.x,b.y)-std::atan2(a.x,a.y))*180/M_PI+360,360);
  }

Dzięki za propozycje implementacji, jednak nie o to pytam. Widzę, że mój algorytm ładnie ubrałeś, ale nie odpowiedziałeś bezpośrednio, czy różnica tych kątów jest logicznie sensowna jako miara kąta między dwoma odcinkami, czy tylko przepisałeś to co ja stworzyłem. Co do samej implementacji, jeszcze raz dziekuję, ale z tym sobie dam radę, bardziej chodzi mi o prawdziwość algorytmu.

Ok, inaczej (btw proszę pisz w postach, bo w komentarzach robi się chos). Mam serię lini które wykryłem na obrazie za pomocą openCV. Chcę stwierdzić, czy bliskie sobie linie mają stosunek ~ 90* czyli są prosotpadłe, czy ~ 180 stopni czyli sa równoległe. Dalej mając informacje o tej relacji analizuję grupy linii i decyduję, czy to są dwie niezależne linie czy "kawałki" jednej dłużej lini która poprzez obróbkę przez OpenCV się "otwarła" na parę odcinków, lub OpenCV ( za pomocą transformaty Hougha ) wykryło 2 linie gdyż na oryginalnym rysunku była ona lekko zakrzywiona bo był to rysunek odręczny,

Tylko uprościłem ten twój kod, oraz zastąpiłem abs(...) na poprawniejsze wg mnie rozwiązanie. Bo ten abs(...) spowoduje że obracając płaszczyznę dookoła dwóch nieruchomych odcinków będziesz dostawać różne wyniki kąta.

prosta przez A,B:

y=x*(By-Ay)/(Bx-Ax) - Ax*(By-Ay)/(Bx-Ax) + Ay
x=y*(Bx-Ax)/(By-Ay) - Ay*(Bx-Ax)/(By-Ay) + Ax

prostopadła do (prostej przez A,B) przez C (zamiast C możesz użyć np A):

y=-x*(Bx-Ax)/(By-Ay) + Cx*(Bx-Ax)/(By-Ay) + Cy
x=-y*(By-Ay)/(Bx-Ax) + Cy*(By-Ay)/(Bx-Ax) + Cx

Obliczasz współczynniki równania i porównujesz sobie.

W skrócie:

• Jeżeli (Ax-Bx)(Cy-Dy) == (Ay-By)(Cx-Dx) to [A-B] równoległa [C-D]
• Jeżeli (Ax-Bx)(Cx-Dx) == (Ay-By)(Cy-Dy) to [A-B] prostopadła [C-D]

Ok, rozumiem. Zatem, czy policzone tak kąty i badanie czy są bliskie 90 lub 180 stopni powie mi, że te odcinki są faktycznie prostopadłe lub równoległe ?? Tutaj już chodzi mi bardziej o samą metodę niż aspekt techniczny.

Ok, dzięki, dużo pomogłeś. Natomiast, jeżeli te równania jakie podałeś będą nie równe, tylko np. różne o jakąś małą delte, wtedy proste są "prawie" równoległe lub "prawie" prostopadłe ?? W praktyce nigdy nie ma takiego czegoś jak prostopadłe i równoległe.

Dzięki za pomoc. Co prawda funkcja dxy() którą zaproponowałeś nie uwzględniała wszystkich przypadków i musiałem torszke ją ulepszyć. Co do koncepcji - lepiej faktycznie liczyć kąt do osi i badać różnicę. Co mi na pewno pomogło - uproszczenie kodu do liczenia kąta większego niż 180*. Reasumując zarówno kąt między dwoma dowolnymi odcinkami da sie policzyć żeby poprzez badanie poszczególnych ich kątów wzlgędem osi x, jak i mierzenie tego kąta (między odcinkami) jest najlepsze do wykrywania prawie równoległych i prawie prostopadłych.