linien.h

Go to the documentation of this file.

// -*- mode: c++; indent-tabs-mode: nil; c-basic-offset: 4; coding: iso-8859-1; -*-

/*
ACT-CV - Machine Vision for Cognitive Modeling
Copyright (c) 2008 Marc Halbruegge

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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef __LINIEN_H
#define __LINIEN_H

#include <iostream>
#include <cmath>
#include <garbagecoll.h>
#include <stdexcept>
#include <Pos.h>

#include "punkt.h"


class PolLinie : virtual public ReferenceCount {
protected:
    //Polardarstellung
    double winkel, polAbs;
public:
    PolLinie(double w=0, double p=0) :
        winkel(w), polAbs(p) {}

    double GetWinkel() const {
        return winkel;
    }
  
    double GetPolAbs() const {
        return polAbs;
    }

    template<class _point>
    double abstand(const _point &p) const {
        return fabs(wert(p));
    }

    template<class _point>
    double wert(const _point &p) const {
        return cos(GetWinkel())*p.x+sin(GetWinkel())*p.y+GetPolAbs();
    }
    
    double wert(const Pos<2,double> &p) const {
        return cos(GetWinkel())*p[0]+sin(GetWinkel())*p[1]+GetPolAbs();
    }
    
    double wert(const DMatrix<2,1> &p) const {
        return cos(GetWinkel())*p[0][0]+sin(GetWinkel())*p[1][0]+GetPolAbs();
    }

    Pos<2,double> SchnittPunkt(const PolLinie &l2) const {
        if (fabs(GetWinkel()-l2.GetWinkel())<1e-8) {
            // parallel
            throw std::runtime_error("parallel lines");
        }
        
        double y=cos(l2.GetWinkel())/cos(GetWinkel())*GetPolAbs()-l2.GetPolAbs();
        y/=sin(l2.GetWinkel())-sin(GetWinkel())*cos(l2.GetWinkel())/cos(GetWinkel());
        
        double x=-y*sin(GetWinkel())-GetPolAbs();
        x/=cos(GetWinkel());
        
        Pos<2,double> result;
        result[0]=x;
        result[1]=y;
        return result;
    }
};

double GetWinkelDiff(double w1, double w2);

class Linie : public PolLinie {
protected:
    //Ecken
    double oben,links,unten,rechts;

    void ComputePolardarstellung() {
#if 0
        if (rechts>links) {
            double yDelta = oben - unten;
            winkel=acos(yDelta/GetLen());
        } else {
            double yDelta = unten - oben;
            winkel=acos(yDelta/GetLen());
        }
#else
        winkel=atan2(rechts-links,oben-unten);
#endif        
        polAbs = - links*cos(winkel) - oben*sin(winkel);
    }
public:
    Linie(double l=0, double o=0, double r=0, double u=0) :
        oben(o), links(l), unten(u), rechts(r) { 
        ComputePolardarstellung();
    }

    template<class _point1, class _point2>
    Linie(const _point1 &p1, const _point2 &p2) :
        oben(p1.y), links(p1.x), unten(p2.y), rechts(p2.x) { 
        ComputePolardarstellung();
    }

    template<class _t>
    Linie(const Pos<2,_t> &p1, const Pos<2,_t> &p2) :
        oben(p1[1]), links(p1[0]), unten(p2[1]), rechts(p2[0]) { 
        ComputePolardarstellung();
    }

    Linie(const DMatrix<2,1> &p1, const DMatrix<2,1> &p2) :
        oben(p1[1][0]), links(p1[0][0]), unten(p2[1][0]), rechts(p2[0][0]) { 
        ComputePolardarstellung();
    }

    double GetLen() const {
        double res = (rechts-links)*(rechts-links) + 
            (oben-unten)*(oben-unten);
        return sqrt(res);
    }
    
    double GetOben() const {
        return oben;
    }
    double GetLinks() const {
        return links;
    }
    double GetUnten() const {
        return unten;
    }
    double GetRechts() const {
        return rechts;
    }

    double abstand(const Linie &l) const {
#if 0
        //erstmal nur die Winkel betrachten
        double res = GetWinkel();
        res -= l.GetWinkel();
        res = fabs(res);
        if (res > _PI / 2) res -= _PI / 2;
        return res;
#else
        /* andere Variante:
         * den Abstand der beiden Eckpunkte einer
         * Linie von der anderen berechnen, dann
         * den groesseren davon ausgeben
         */
        double a1 = PolLinie::abstand(Punkt((int)l.GetLinks(),(int)l.GetOben()));
        double a2 = PolLinie::abstand(Punkt((int)l.GetRechts(),(int)l.GetUnten()));
        return a1 > a2 ? a1 : a2;
#endif
    }

    double abstand(const PolLinie &l) const {
        double a1 = l.abstand(Punkt((int)GetLinks(),(int)GetOben()));
        double a2 = l.abstand(Punkt((int)GetRechts(),(int)GetUnten()));
        return a1 > a2 ? a1 : a2;
    }

    template<class _point>
    double abstand(const _point p) const {
        return PolLinie::abstand<_point>(p);
    }
    
    Pos<2,double> SchnittPunktAufStrecke(const PolLinie &l2) const {
        Pos<2,double> result=SchnittPunkt(l2);
        Pos<2,double> lo(links,oben);
        Pos<2,double> ru(rechts,unten);
        
        double s=Len(lo-ru);
        double slo=Len(lo-result);
        double sru=Len(ru-result);
        if (slo>s || sru>s) {
            // außerhalb der Strecke
            if (slo<sru) {
                return lo;
            } else {
                return ru;
            }
        }
        return result;  
    }
    
    bool IstAufStrecke(const Pos<2,double> &p) const {
        return IstAufStrecke(DMatrix<2,1>(p));
    }
    bool IstAufStrecke(const DMatrix<2,1> &p) const {
        DMatrix<2,1> lo(links,oben);
        DMatrix<2,1> ru(rechts,unten);
        
        double s=Len(lo-ru);
        double slo=Len(lo-p);
        double sru=Len(ru-p);
        if (slo>s || sru>s) {
            return false;
        } else {
            return true;
        }
    }
};

static std::ostream& operator << (std::ostream &o, const Linie &l);

#endif