Package fmg.fmg8.umgebung2D

Examples of fmg.fmg8.umgebung2D.Vektor2D


                            x1 = pol.xpoints[0];
                            x2 = pol.xpoints[1];
                            y1 = pol.ypoints[0];
                            y2 = pol.ypoints[1];

                            Vektor2D verschOrtho = new Vektor2D(x1, y1);
                            verschOrtho.sub(new Vektor2D(x2, y2));
                            Vektor2D verschPar = new Vektor2D(verschOrtho);
                            verschPar.normal();
                            verschPar.mult(30);
                            verschOrtho.ortho();
                            verschOrtho.normal();
                            verschOrtho.mult(-10);
                            Vektor2D versch = new Vektor2D(verschPar);
                            versch.add(verschOrtho);
                           
                            x = (int) (((double) x1 + (double) x2) / 2.0
                                    + versch.x);
                            y = (int) (((double) y1 + (double) y2) / 2.0
                                    + versch.y);
View Full Code Here


            final Polygon2D pfeilAnfang,
            final Polygon2D pfeilEnde,
            final Vektor2D            anfFaktor,
            final Vektor2D            endFaktor) {

        Vektor2D aktVekX;
        Vektor2D aktVekY;
        Vektor2D aktVek;
        Strecke2D p, q;
       
        if (punkte == null || punkte.size() < 2) {
            throw new RuntimeException("Zu wenige Segmente f�r Pfeil.");
        }
       
        ArrayList<Double> dick = dicken;
       
        if (dick == null) {
            dick = new ArrayList<Double>(punkte.size());
            for (int i = 0; i < punkte.size(); i++) {
                dick.add((double) this.pfeilDicke);
            }
        }
       
        Polygon2D pktList1 = new Polygon2D(punkte.size()
                                           + pfeilAnfang.size()
                                           + pfeilEnde.size());
        Polygon2D pktList2 = new Polygon2D(pktList1.size());

        // Pfeilanfang.
        Vektor2D normAnf = new Vektor2D(punkte.get(0));
        Vektor2D orthoAnf;
        normAnf.sub(punkte.get(1));
        normAnf.normal();
        orthoAnf = new Vektor2D(normAnf);
        orthoAnf.ortho();
        Iterator<Vektor2D> it1 = pfeilAnfang.iterator();
        Polygon2D zwisch = new Polygon2D(pfeilAnfang.size());
       
        while (it1.hasNext()) {
            aktVek = it1.next();
            aktVekX = new Vektor2D(orthoAnf);
            aktVekY = new Vektor2D(normAnf);
            aktVekX.mult(aktVek.x * anfFaktor.x * dick.get(0));
            aktVekY.mult(aktVek.y * anfFaktor.y * dick.get(0));
            aktVek = new Vektor2D(aktVekX);
            aktVek.add(aktVekY);
            aktVek.add(punkte.get(0));
            zwisch.add(aktVek);
        }
       
        for (int i = zwisch.size() - 1; i >= 0; i--) {
            pktList2.add(zwisch.get(i));
        }

        Polygon2D zwischPunkte;
       
        Vektor2D c1 = new Vektor2D(punkte.get(1));
        Vektor2D c2;
        c1.sub(punkte.get(0));
        c1.ortho();
        c1.normal();
        c1.mult((double) dick.get(0) / 2);
       
        Vektor2D p01 = new Vektor2D(punkte.get(0));
        Vektor2D p02 = new Vektor2D(p01);
        Vektor2D p11;
        Vektor2D p12;
       
        p01.add(c1);
        p02.sub(c1);
       
        pktList1.add(p01);
        pktList2.add(p02);
       
        for (int i = 1; i < punkte.size() - 1; i++) {
            zwischPunkte = fmg.fmg8.graphVis.zeichenModi.Geometrie2D.schnPkte(
                    punkte.get(i - 1),
                    punkte.get(i),
                    punkte.get(i + 1),
                    dick.get(i));
           
            p = new Strecke2D(
                    zwischPunkte.get(0),
                    zwischPunkte.get(1));
            q = new Strecke2D(
                    pktList1.get(pktList1.size() - 1),
                    pktList2.get(pktList2.size() - 1));
           
            if (p.schnPkt(q) == null) {
                pktList1.add(zwischPunkte.get(0));
                pktList2.add(zwischPunkte.get(1));
            } else {
                SonstMeth.log(SonstMeth.LOG_WARNING,
                              "Segment konnte nicht �berschneidungsfrei "
                              + "platziert werden um Pixel: " + punkte.get(i),
                              this.pars,
                              "",
                              punkte.get(i));
                pktList1.add(zwischPunkte.get(0));
                pktList2.add(zwischPunkte.get(1));
            }
        }
       
        c2 = new Vektor2D(punkte.get(punkte.size() - 1));
        c2.sub(punkte.get(punkte.size() - 2));
        c2.ortho();
        c2.normal();
        c2.mult((double) dick.get(punkte.size() - 1) / 2);
       
        p11 = new Vektor2D(punkte.get(punkte.size() - 1));
        p12 = new Vektor2D(p11);
       
        p11.add(c2);
        p12.sub(c2);
       
        pktList1.add(p11);
        pktList2.add(p12);
       
        // Pfeilspitze.
        Vektor2D normEnd = new Vektor2D(punkte.get(punkte.size() - 1));
        Vektor2D orthoEnd;
        normEnd.sub(punkte.get(punkte.size() - 2));
        normEnd.normal();
        orthoEnd = new Vektor2D(normEnd);
        orthoEnd.ortho();

        Iterator<Vektor2D> it2 = pfeilEnde.iterator();
       
        while (it2.hasNext()) {
            aktVek = it2.next();
            aktVekX = new Vektor2D(orthoEnd);
            aktVekY = new Vektor2D(normEnd);
            aktVekX.mult(aktVek.x * endFaktor.x * dick.get(dick.size() - 1));
            aktVekY.mult(aktVek.y * endFaktor.y * dick.get(dick.size() - 1));
            aktVek = new Vektor2D(aktVekX);
            aktVek.add(aktVekY);
            aktVek.add(punkte.get(punkte.size() - 1));
            pktList1.add(aktVek);
        }

View Full Code Here

        return this.segmentPfeilPol2D(
                punkte,
                null,
                PfeilMaster.EINFACHER_ABSCHLUSS,
                PfeilMaster.EINFACHE_SPITZE_2,
                new Vektor2D(1, 1),
                new Vektor2D(1, 1));
    }
View Full Code Here

            final List<Integer> markierung,
            final AusgMerkm mark,
            final AusgMerkm unmark,
            final double radius) {
       
        Vektor2D v;
        Kreis2D k;
       
        for (int i = 0; i < p.npoints; i++) {
            if (markierung.contains(i)) {
                l.add(mark);
            } else {
                l.add(unmark);
            }
            v = new Vektor2D(p.xpoints[i], p.ypoints[i]);
            k = new Kreis2D(v.x, v.y, radius);
            l.add(k);
        }
    }
View Full Code Here

        Polygon2D aktPunkte = new Polygon2D();
        ArrayList<Double> aktDicken = new ArrayList<Double>();
        PfeilMaster zeichnen = new PfeilMaster(params);
        AusgMerkm ausg;
        GradientPaint grad;
        Vektor2D p1Old, p2Old, p1, p2, v1, v2, zwisch;
        Color fuell, rahmen;
       
        for (int i = 0; i < segBeschr.length; i++) {
            if (segBeschr[i] != null) {
                aktPunkte.clear();
                aktDicken.clear();
                for (int j = segBeschr[i].getBeginn();
                 j <= segBeschr[i].getEnde(); j++) {
                    aktPunkte.add(punkte.get(j));
                    if (dicken != null) {
                        aktDicken.add(dicken.get(j));
                    } else {
                        aktDicken.add((double) Konstanten.PFEIL_DICKE);
                    }
                 }
               
                aktPol = zeichnen.segmentPfeilPol2D(
                        aktPunkte,
                        aktDicken,
                        segBeschr[i].getPfeilAnfang(),
                        segBeschr[i].getPfeilEnde(),
                        segBeschr[i].getFaktorAnfang(),
                        segBeschr[i].getFaktorEnde());
               
                ausg = segBeschr[i].getAusg();
               
                if (ausg != null && ausg.getGradPaint() != null) {
                    p1Old = new Vektor2D(
                            ausg.getGradPaint().getPoint1().getX(),
                            ausg.getGradPaint().getPoint1().getY());
                    p2Old = new Vektor2D(
                            ausg.getGradPaint().getPoint2().getX(),
                            ausg.getGradPaint().getPoint2().getY());
                    v1 = new Vektor2D(aktPunkte.get(aktPunkte.size() - 1));
                    v1.sub(aktPunkte.get(0));
                    v2 = new Vektor2D(v1);
                    v2.ortho();
                   
                    p1 = new Vektor2D(v1);
                    p1.mult(p1Old.y);
                    zwisch = new Vektor2D(v2);
                    zwisch.mult(p1Old.x);
                    p1.add(zwisch);
                    p1.add(aktPunkte.get(0));
                   
                    p2 = new Vektor2D(v1);
                    p2.mult(p2Old.y);
                    zwisch = new Vektor2D(v2);
                    zwisch.mult(p2Old.x);
                    p2.add(zwisch);
                    p2.add(aktPunkte.get(0));
                   
                    grad = new GradientPaint(
View Full Code Here

        List<Object> l;
        Polygon2D bez2 = new Polygon2D();
        ArrayList<Double> dicken = new ArrayList<Double>();
       
        for (double i = 0; i < Math.PI * 2; i += 0.0001) {
            bez2.add(new Vektor2D(Math.sin(i) * 10, Math.cos(i) * 10));
        }
       
        bez2 = bez2.normalisiere();

        for (double i = 0; i < bez2.size(); i++) {
            dicken.add(
                    Math.sin((i / bez2.size() * Math.PI * 4) * 4
                    + Math.sin(i / bez2.size() * Math.PI * 6) * 1
                    + Math.sin(i / bez2.size() * Math.PI * 8) * 2) * 3 + 4.5);
        }
       
        a1.setGradPaint(-3f, 0, Color.green, 3f, 0, Color.red);
        a2.setGradPaint(-3f, 0, Color.darkGray, 3f, 0, Color.blue);
       
        AusgMerkm[] ausg = new AusgMerkm[2];
        ausg[0] = a1;
        ausg[1] = a2;
       
        Pol2DMitAusgMerkm[] seg = zeichnen.gestrichelterPfeil(
                bez2,
                dicken,
                PfeilMaster.RUECK_PFEIL,
                PfeilMaster.RUECK_PFEIL,
                new Vektor2D(1, 1),
                new Vektor2D(1, 1),
                ausg,
                0.1,
                params);

        Polygon2D pol = new Polygon2D();
        pol.add(new Vektor2D(0, 15));
       
        l = Geometrie2D.erzeugeObjList(seg, 100, Vektor2D.NULL_VEKTOR);

        l.add(0, new AusgMerkm(Color.blue, Color.black, true, true));
        l.add(pol.toPol(100, Vektor2D.NULL_VEKTOR));
View Full Code Here

        // Kollisionen
        int fitKoll = (int) ((double) rob.getAnzUnfaelle()
                 * rob.getPars().getAbzugUnfall().doubleValue());
        rob.resetAnzUnf();
        double abstand1, abstand2;
        Vektor2D mitte1, mitte2;
       
        // Aus Collision avoidance (nur MOVE-Teil):
        int bef0 = ((Integer) rob.getBefehle().get(0)).intValue();
        String befehl0 = fmg.fmg8.umgebung2D.Konstanten.BEF[bef0].toUpperCase();
        int fitCollAvoid = 1;
View Full Code Here

     * @param rob  Der Roboter, dessen Positionierung bestimmt werden soll.
     *
     * @return  Der Quadrant des Roboters.
     */
    private String quadrant(final Roboter rob) {
        Vektor2D mitte = rob.getUmg().getDynWaende()[221].mittelpunkt();
        Vektor2D robPos = rob.getPosition();
        String quadrant = "";
       
        if (robPos.x > mitte.x && robPos.y > mitte.y) {
            quadrant = "SO";
        }
View Full Code Here

        xQ = x + this.knotenDurchm / 2.0;
        yQ = y - this.knotenDurchm / 2.0;
        quadrat.addPoint((int) xQ, (int) yQ);

        return fmg.fmg8.graphVis.zeichenModi.Geometrie2D.kreis(
                new Vektor2D(x, y),
                31,
                (int) (1 / this.pars.getBezier()));
    }
View Full Code Here

                            x1 = pol.xpoints[0];
                            x2 = pol.xpoints[1];
                            y1 = pol.ypoints[0];
                            y2 = pol.ypoints[1];

                            Vektor2D verschOrtho = new Vektor2D(x1, y1);
                            verschOrtho.sub(new Vektor2D(x2, y2));
                            Vektor2D verschPar = new Vektor2D(verschOrtho);
                            verschPar.normal();
                            verschPar.mult(30);
                            verschOrtho.ortho();
                            verschOrtho.normal();
                            verschOrtho.mult(-10);
                            Vektor2D versch = new Vektor2D(verschPar);
                            versch.add(verschOrtho);
                           
                            x = (int) (((double) x1 + (double) x2) / 2.0
                                    + versch.x);
                            y = (int) (((double) y1 + (double) y2) / 2.0
                                    + versch.y);
View Full Code Here

TOP

Related Classes of fmg.fmg8.umgebung2D.Vektor2D

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.